Från insekter till fåglar och rovdjur – så fick man sitt namn i runornas tid


<p><strong>»Björnen och vargen var fruktade djur, som ägde styrka, snabbhet och mod. Örnen, fåglarnas konung, var ståtlig och segerrik i kamp med andra djur. Dylika gåvor önskade våra förfäder sina gossebarn.»</strong></p>



<p>Orden ovan är namnforskaren Assar Janzéns när han 1947 skulle för­klara användningen av djurbeteckningar som personnamn under äldsta tid. De namn som han tänkte på var sådana som fornsvenska <em>Biørn, Ulv och Ari</em>. Dessa ingick under vikinga­tiden även i mängder av sammansatta namn och då inte bara i mansnamn. Annorlunda var det enligt Janzén med namn som <em>Ræv, Spirv, Hani</em> och <em>Foghel</em> som aldrig förekom i denna typ av sammansatta namn. Dessa ska i stället från början ha varit en form av karakteriserande öknamn, som genom uppkallelse efter tidigare bärare hade upphöjts till dop­namn.</p>



<figure class="wp-block-image size-full"><img src="https://elbilen.se/wp-content/uploads/sites/3/2025/05/Fig.-1.-Vr-1-Jarsbergsstenen-B.-A.-Lundberg-scaled.jpg" alt="" class="wp-image-5433"/><figcaption class="wp-element-caption">Järsbergsstenen utanför Kristinehamn, där runmästaren fått namn efter korpen. Foto: Bengt A. Lundberg, Arkivsök RAÄ</figcaption></figure>



<p>Man vill gärna tänka sig att denna typ av enkla namn som hämtades från redan existerande begrepp i den omgivande naturen skulle tillhöra de allra tidigaste. Personnamn med djuranknytning förekommer också redan i de äldsta runinskrifterna. På ett knivskaft från det stora romartida vapenofferfyndet i Kragehul på Fyn i Danmark finns bland annat runföljden <strong>bera</strong> som har tolkats som ett mansnamn <em>Bera</em>, bildat till ett ord för ’björn’.&nbsp;</p>



<p>Ett annat exempel finns på Järsbergsstenen utanför Kristinehamn i Värmland, som bär en inskrift med en både komplicerad och omtvistad läsordning. Troligen ska den uppfattas så här:</p>



<p><strong>eke͡rilaʀ | …ubaʀ hite </strong>⁝<strong>h͡arabana͡ʀ |</strong> <strong>h͡ait… | runoʀ waritu</strong><br><em>Ek, erilaʀ, </em>[<em>Le</em>]<em>uƀaʀ</em>(?)<em> haitē. Hraƀnaʀ hait</em>[<em>eka</em>]<em>, rūnōʀ wrītu.</em><br>»Jag, erilen, heter Ljuv(?). Ravn heter jag, som skriver runorna.»</p>



<p><em>Hraƀnaʀ</em> – isländskans <em>hrafn</em> – är ett gammalt ord för ’korp’ och precis som detta skapat i ett försök att efterlikna fågelns läte. Mycket talar för att »erilen» och runmästaren här är en och samma person och han har i så fall haft två namn, där det senare återgår på en djurbeteckning.&nbsp;</p>



<p>På den norska Hogganviksstenen, som kom i dagen 2009, står på ett ställe <strong>ek erafaʀ</strong>, vilket har tolkats som »Jag Järven», alltså ännu ett exempel på någon som verkar har gjort ett ursprungligt öknamn till sitt. I <em>Historia om de nordiska folken</em>, som trycktes första gången i Rom 1555, berättar Olaus Magnus att järven är känd för sin glupskhet och hur den gör sig av med maginnehållet genom att tränga sig mellan två tätt stående träd för att sedan kunna sätta igång och äta igen. »Det tyckes av naturen vara skapat sådana människor till blygd, som omåttligt äta och dricka, tills de spy, och sedan sätta sig till bords igen och så hålla på natt och dag», skriver Olaus.</p>



<figure class="wp-block-image size-full"><img src="https://elbilen.se/wp-content/uploads/sites/3/2025/05/Fig.-2.-DR-195-Knivskaft-fran-Kragehul.jpg" alt="" class="wp-image-5434"/><figcaption class="wp-element-caption">Knivskaftet från Kragehul på Fyn, som bär mansnamnet Bera. Teckning: Magnus Petersen hos Stephens 1866–67.</figcaption></figure>



<p>I de sammansatta namnen är det som nämnts andra rovdjur som vi främst möter. På en rosettfibula från Himlingøje på Själland, daterad så tidigt som till 200-­talet, står mansnamnet<strong>ẉiduhudaʀ</strong>, som ska utläsas som <em>Widuhundaʀ</em> »Skogshund». Här har man vid namngivningen nog inte tänkt på någon vanlig hund, utan på den som lever i skogen, naturligtvis vargen. På Istabystenen från Blekinge, som i dag står i utställningen på Historiska museet i Stockholm, kan man läsa att »Hådulv, Hjorulvs ättling, skrev runorna efter Härjulv». Alla tre bär här namn som slutar på &#8211;<em>wulfaʀ</em> ’ulv’ och de har säkert tillhört samma familj. Förlederna i namnen anknyter genomgående till krigiska aktiviteter: *<em>haþō</em> ’strid’, *<em>heruʀ</em> ’svärd’ och *<em>harjaʀ</em> ’(krigs)här’. Troligen kunde man under den tid som det här handlar om – 600-­talet – ännu utläsa en mening i sammansättningarna: ’stridsulven, ’svärdsulven’ etc. Annorlunda var det på vikingatiden då namnlederna i de sammansatta namnen kunde kombineras helt fritt utan tanke på betydelsen.</p>



<p>De sammansatta namnen var mycket populära under vikingatiden, vilket inte minst framgår av den namnskatt som utgör en stor del av runstenarnas texter. Lena Peterson listar i <em>Nordiskt runnamnslexikon</em> från 2007 exempelvis inte mindre än 51 sammansättningar med &#8211;<em>bi</em><em>ǫ</em><em>rn</em> och 53 med &#8211;<em>ulf</em><em>ʀ</em>. Dessa två namnleder verkar också ha kunnat kombineras i stort sett med vilka andra namnleder som helst, vilket inte minst framgår av att listan upptar ett namn <em>Biarnulf</em><em>ʀ</em> »Björnulv», som ju är en zoologisk omöjlighet.</p>



<p>Substantiven i fornspråket böjdes efter genus det vill säga i maskulinum, femininum och neutrum precis som i dagens tyska. Detta hade också betydelse för hur orden kunde användas i namnbildningen. I sammansatta namn är den senare leden huvudleden som rättar sig efter bärarens biologiska kön. Det betyder att den i mansnamn bara kan utgöras av maskulina ord och i kvinnonamn bara av feminina. I den förra leden var det däremot fritt fram för vilket genus som helst. Därför kan vi i kvinnonamnen också finna de maskulina orden <em>ulf</em><em>ʀ</em> och <em>orm</em><em>ʀ</em> som i <em>Ulfhildr</em> och <em>Ormhildr</em> eller varianter av ordet <em>arn</em> ’örn’ som i <em>Arngærðr, Ærnlaug</em> och <em>Ærinvī</em>.</p>



<figure class="wp-block-image size-full"><img src="https://elbilen.se/wp-content/uploads/sites/3/2025/05/Fig.-3.-Og-132-Heda-kyrka-foto-MK.jpg" alt="" class="wp-image-5435"/><figcaption class="wp-element-caption">Runstenen i Heda kyrka i Östergötland, som restes till minne av mannen som hette Myra. Foto: Magnus Källström, RAÄ</figcaption></figure>



<p>När djurbeteckningar användes som binamn spelade det däremot ingen som helst roll vilket genus det ursprungliga ordet hade. Namnet <em>Bersa</em> eller <em>Birsa</em> som förekommer på flera runstenar är identiskt med ordet *<em>birsa</em> som betyder ’björnhona’, men som bara förekommer som namn på män. På runstenarna ser det ut som ett vanligt dopnamn, men det bör från början ha varit ett binamn förmodligen syftande på någon med lufsande gång. På samma sätt kunde en man också heta <em>Arta</em> »Årta» efter and­fågeln med detta namn, trots att ordet är femininum.&nbsp;</p>



<p>Just fågelbeteckningar är mycket vanliga som personnamn och man undrar om det inte var något i fåglarnas uppträdande eller utseenden som gjorde dem särskilt tacksamma att använda som grund för öknamn. Den som kallades <em>Pāi</em> ’påfågel’ gillade nog att klä sig i färgstarka kläder precis som Olaf Påfågel i den isländska Laxdalasagan, medan man bakom namnet <em>Skāri</em> ’ungmås’ kan misstänka ett omoget uppträdande. Det är inte heller svårt att föreställa sig hur <em>Skarf</em><em>ʀ</em> ’skarv’, som enligt Balstastenen utanför Eskilstuna for österut med Ingvar den vittfarne, kan ha sett ut och betett sig.&nbsp;</p>



<p>Även de minsta djur kunde vara namnlåtande. En runsten som sitter inmurad i Heda kyrka i Östergötland är exempelvis tillägnad en man med namnet <em>M</em><em>ȳ</em><em>r</em> som betyder ’myra’. Lustigt nog var han enligt inskriften bosatt i <em>Iatunstaði</em><em>ʀ</em>, dagens Jättingstad, en bebyggelse som har namngetts efter en varelse med helt andra dimensioner. Troligen bar gårdens grundare (bi)namnet <em>Iatunn</em> ’Jätten’ och man undrar givetvis om ortnamnet på något sätt kan ha spelat en roll när den inbyggare som nämns på Hedastenen fick sitt namn.&nbsp;</p>



<figure class="wp-block-image size-full"><img src="https://elbilen.se/wp-content/uploads/sites/3/2025/05/runa-lindgsberg-scaled.jpg" alt="" class="wp-image-5438"/><figcaption class="wp-element-caption">Den ena Lingsbergsstenen i Vallentuna, där man möter björn. Foto: Harald Faith-Ell, ATA</figcaption></figure>



<p>En av runstenarna vid det gamla vadet vid Ullunda utanför Enköping i Uppland är rest efter en man, vars namn skrivs <strong>mursa</strong>. Denne hade enligt inskriften varit i Grekland och förvärvat gods åt sin arvinge, och länge tänkte man sig att namnet var felristat för <strong>hursa</strong> och skulle tolkas som <em>Horsi</em> eller <em>Haursi</em>. Runologen Patrik Larsson har dock föreslagit att det kan handla om en bildning till det nämnda <em>M</em><em>ȳ</em><em>r</em> och <em>-si</em> kan då vara ett så kallat diminutivsuffix, alltså en <em>liten</em> myra! Namnet är säkert inte det värsta som har kunnat myntas i ett testosteronstint grabbgäng på båtfärd till Bysans.&nbsp;</p>



<p>Man kan undra vart kvinnorna har tagit vägen i detta sammanhang, men en orsak till deras frånvaro är att de sällan uppträder i runstenstexterna med binamn eller med namn med sådant ursprung. I stället möter här i regel två­ledande namn som <em>Guðlaug</em> och <em>Ingigærðr</em> eller kortformer som <em>Þōra</em> och <em>Holma</em>. Det enda kvinnonamn från runstenarna som bygger på en fågelbeteckning är <em>Gās</em> ’Gås’, vilket kanske kan tyckas lite oförskämt. I verkligheten finns hela gåsfamiljen representerad i det vikingatida namnskicket. Såväl <em>Gāsi</em> ’gåskarl’ som <em>Gæsling</em><em>ʀ</em> ’gässling’ förekommer nämligen som personnamn i runinskrifterna. Ordet <em>gās</em> har dessutom trots sitt feminina genus kunnat användas som binamn på män. En medeltida gravhäll från Ukna ödekyrka i Småland är exempelvis lagd över Tyrgils, som var son till »Herr Gudmund Gås».</p>



<p>I nordisk folktro fanns föreställningen om att alla människor hade en fylgja som gärna visade sig i drömmar och då ofta i djurgestalt. Exempelvis berättas i den isländska Njalssagan om hur Njal och hans huskarl Tord sitter ute på gårdstunet, där en bock brukade gå och beta. Plötsligt säger Tord att han ser bocken ligga död i en svacka en bit från gården. Njal kan däremot inte se någonting och inser att Tord har sett sin fylgja och att han är förutbestämd att dö. Mycket riktigt blir Tord senare dräpt.&nbsp;</p>



<figure class="wp-block-image size-full"><img src="https://elbilen.se/wp-content/uploads/sites/3/2025/05/Runor2.jpg" alt="" class="wp-image-5440"/><figcaption class="wp-element-caption">Konstiga kroppar på Måstastenen i Balingsta. Foto: Bengt A. Lundberg, Arkivsök RAÄ</figcaption></figure>



<p>Hoskuld Dala-Kollsson i samma saga ser i en dröm hur en stor björn åtföljd av två björnungar lämnar hans hem för att bege sig till hans bror Hrut. Hoskuld förstår då att det är Gunnar på Lidarändes fylgja som han har sett och att Gunnar tidigare måste ha besökt de båda brödernas gårdar förklädd och utan att bli igenkänd. På samma sätt drömmer Gunnar om en vargattack innan han och hans bröder senare blir överfallna.</p>



<p>Hos den uppländske runristaren Åsmund Kåresson förekommer en hel del djurbilder, vars betydelse inte alltid är så lätt att genomskåda. På en av runstenarna vid Lingsberg i Vallentuna ser man exempelvis innanför slingorna dels en mansfigur, dels en björn som sitter på rumpan. Det vore onekligen lite frestande att tänka sig att det föreställer den döde Ulvrik och hans fylgja. Den senare skulle i så fall precis som var fallet med Gunnar på Lidarände uppträda i björnskepnad.&nbsp;</p>



<p>Björnfigurer är samtidigt inte helt ovanliga hos Åsmund och det är nog troligare att de har en annan betydelse. På den ena Måstastenen i Balingsta förekommer en björn tillsammans med tre andra djurfigurer: en kattdjursliknande varelse, ett stort fyrfotadjur som nafsar efter korset och något som ser ut som ett lejon med människohuvud, alltså en sfinx! Visserligen bär en av dem som har rest stenen namnet <em>Fastbi</em><em>ǫ</em><em>rn</em>, men djuren kommer troligen från ett helt annat sammanhang. Enligt ett tilltalande förslag av runologen Henrik Williams kan det faktiskt handla om ett gammaltestamentligt motiv från Daniels bok, där Daniel i en dröm ser fyra vilddjur i olika skepnader stiga upp ur havet. Dessa symboliserar fyra kungariken som alla gick under, vilket av de kristna sågs som ett förebud om den yttersta domen.&nbsp;</p>



<figure class="wp-block-image size-large"><img src="https://elbilen.se/wp-content/uploads/sites/3/2025/05/Runor1-1024x825.jpg" alt="" class="wp-image-5439"/><figcaption class="wp-element-caption">Tullstorpsstenen i Skåne med löpande varg. Foto: Magnus Källström, RAÄ</figcaption></figure>



<p>Över ristningsytan på den skånska Tullstorpsstenen löper ett fyrfotadjur med huggtänder och ragg på både rygg och svans. Det råder knappast någon tvekan om att det föreställer en varg. Vissa tror att denna bildframställning hänger samman med att den döde bar namnet <em>Ulf</em><em>ʀ</em>, men av allt att döma har ristaren haft en annan tanke. Nedtill på stenen avbildas nämligen ett märkligt skepp med ett råttliknande djurhuvud med vassa tänder i fören och en halvmänsklig varelse med långa kaninöron vid styr­åran. Uppenbarligen handlar det om en framställning av skeppet Nagelfar som vid Ragnarök ska transportera de onda makterna till den slutgiltiga striden. Den som står vid styråran är alltså Loke eller jätten Hrym beroende på vilken källa man väljer att tro på. Vargen som gör Nagelfar sällskap på stenen är givetvis Fenrisulven. Det är alltså äkthedniska motiv som möter på denna runsten, som har varit inmurad i Tullstorps kyrka och som i dag står på kyrkogården omgiven av en urnlund. Även om stenen saknar alla tecken på kristendom, är det inte uteslutet att bilderna ska tolkas i ett kristet sammanhang. Av framställningar på andra runstenar framgår nämligen att scener från Ragnarök även har kunnat användas för att symbolisera den ytter­sta domen.&nbsp;</p>



<figure class="wp-block-image size-large"><img src="https://elbilen.se/wp-content/uploads/sites/3/2025/05/Fig.-7.-Pafageln-pa-U-874-Hagby-kyrka-foto-MK-1024x768.jpg" alt="" class="wp-image-5436"/><figcaption class="wp-element-caption">Påfågeln på den år 2016 återfunna runstenen vid Hagby kyrka i Uppland. Foto: Magnus Källström, raä</figcaption></figure>



<p>Inte bara björnar, vargar och andra fyrfotadjur dyker upp som bilder på runstenarna, utan även fåglar. Syftet med dessa bilder har nog växlat. En del är kanske bara dekorativa, medan andra bör ha en djupare mening. Den påfågel­figur som uppträder på samma plats som korset på flera av runristaren Fots stenar ska exempelvis säkert uppfattas som en kristen symbol och då snarast för uppståndelsen och det eviga livet.&nbsp;</p>



<p>I Haninge söder om Stockholm finns flera runristningar, där en fågelfigur har placerats ovanpå korset. Av utformningen att döma handlar det om en tupp och i flera fall mer specifikt om en tjädertupp. I eddadikten Völuspá nämns tre tuppar som ger hals inför Ragnarök. Först gal Fjalar – »en fagerröd (ljusröd) hane» – hos jättarna, därefter tuppen Gullinkambe hos asarna och slutligen en icke namngiven »sotröd (mörkröd) hane» i underjorden hos dödsgudinnan Hel. Kanske är det någon av dessa varnande tuppar som Haningeristarna har haft i åtanke.&nbsp;</p>



<figure class="wp-block-image size-full"><img src="https://elbilen.se/wp-content/uploads/sites/3/2025/05/Fig.-8.-So-270-Tyresta-H.-Faith-Ell-scaled.jpg" alt="" class="wp-image-5437"/><figcaption class="wp-element-caption">Tyrestahällen i Österhaninge, där tuppen toppar korset. Foto: Harald Faith-Ell, ATA</figcaption></figure>



<p>Att tuppen på flera av ristningarna har framställts som en tjädertupp har säkert sin speciella orsak. I namnet <em>Haninge</em> ingår inbyggarbeteckningen *<em>hanungar</em>, som avser dem som bor vid skogen Hanveden. Denna skog bör ha fått sitt namn för att det där fanns gott om skogsfågel som tjäder och orre. Kanske hade tjädertuppen redan då blivit en symbol för bygden på samma sätt som den i dag tronar högst upp i Haninges kommunvapen.&nbsp;</p>



<p>I ortnamnsforskningens barndom trodde man att <em>Haninge</em> i stället innehöll ett patronymikon *<em>Hanunger</em> ’avkomling till Hane’. Basen skulle alltså vara ett av de namn som Janzén drog fram som exempel på öknamn bildade till djurbeteckningar. Det är dock närmast givet att det är skogen <em>Hanveden</em> som här har varit namngivande. Namnet <em>Hani</em> verkar dessutom ha varit ganska ovanligt. Förutom att det ingår i några gårdnamn på &#8211;<em>sta</em>, tycks det bara ha fästs i runor en enda gång, nämligen på den rikt ornerade lockhällen till en gravkista, som sitter inmurad i Sundby kyrka i Södermanland. Om det namnlåtande djuret i detta fall har varit en tjädertupp eller en helt vanlig tupp lär vi aldrig få veta. &nbsp;</p>
