Jakten på kungen

Jakten på svensk vikingakung funnen.


<h2 class="wp-block-heading" style="font-size:25px"><mark class="has-inline-color has-luminous-vivid-orange-color">&#8211; Paparazzi på 1000-talet</mark></h2>



<p class="has-medium-font-size"><strong>Gorm den gamle, Harald Blåtand, Sven Tveskägg alla har de låtit resa runstenar. Andra danska vikingatidskungar som Knut den store och Harald Harfot finns omnämnda på runstenar i Sverige. Men var håller de svenska kungarna hus?</strong></p>


<div class="wp-block-image">
<figure class="alignright size-large is-resized"><img fetchpriority="high" decoding="async" src="https://elbilen.se/wp-content/uploads/sites/3/2023/02/Bild-1-1024x767.jpg" alt="" class="wp-image-3308" width="482" height="361" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Runstenen vid Hovgården på Adelsö, som Tole Bryte lät resa på uppmaning av kungen. Foto: Magnus Källström, RAÄ</mark></strong></figcaption></figure></div>


<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">I VIKINGATIDENS SLUTSKEDE</mark></strong> restes flera tusen runstenar i Sverige, men det finns bara en som med säkerhet har tillkommit på uppdrag av en svensk kung. Den finns vid Hovgården på Adelsö i Uppland, mitt emot Björkö och den plats där staden Birka en gång låg. När stenen ristades hade denna stad legat öde sedan hundra år. Kungen i fråga hette Håkon Röde och ska enligt historiska källor ha regerat från mitten av 1070-talet och ett drygt decennium framåt. Inskriften brukar vanligtvis översättas på följande sätt:</p>



<div class="wp-block-columns is-layout-flex wp-container-core-columns-is-layout-9d6595d7 wp-block-columns-is-layout-flex">
<div class="wp-block-column is-layout-flow wp-block-column-is-layout-flow" style="flex-basis:30px"></div>



<div class="wp-block-column is-layout-flow wp-block-column-is-layout-flow" style="flex-basis:70%">
<p><em>»Tyd du runorna! Rätt lät Tolir, bryte i Roden, rista dem åt konungen. Tolir och Gylla lät rista [dessa runor] båda makarna efter sig till minnesvård &#8230; Håkon bjöd rista.»</em></p>
</div>
</div>



<p>Tolir (eller Tole som den nusvenska formen borde lyda) har alltså enligt denna tolkning låtit rista stenen till minne av sig själv och sin hustru på uppmaning av kungen. Vi får också veta att han var bryte, vilket på vikingatiden var en beteckning för den som var arbetsledare för trälarna och själv ofri. Eftersom ordet på Hovgårdsstenen nämns tillsammans med Roden – kustavsnittet i Uppland som under medeltiden skulle utrusta ledungsflottan och stå för kustförsvaret – har man antagit att han har varit förvaltare på kungsgården på Adelsö.</p>


<div class="wp-block-image">
<figure class="alignright size-full is-resized"><img decoding="async" src="https://elbilen.se/wp-content/uploads/sites/3/2023/02/Bild-2.-Hovgarden-lagunhamn.jpg" alt="" class="wp-image-268" width="484" height="423" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Lagunhamnen vid Hovgården där runstenen kan ha fungerat som ettinseglingsmärke. Efter Brunstedt 1996.</mark></strong></figcaption></figure></div>


<p>   För några år sedan kom ett par nytolkningar av denna inskrift. En gör gällande att stenen inte alls är rest till minne av bryteparet utan tillägnad en namnlös kung och att Håkon är namnet på en jarl. En annan (som har författaren av denna artikel till upphovsman) följer här den traditionella uppfattningen, men ifrågasätter i stället om det verkligen är Roden som nämns på stenen. Ordet<em> rōðr</em> (ristat <strong>roþ</strong>) skulle nämligen här i stället kunna avse en farled eller en inseglingsränna. Det har nämligen länge varit känt att det stenblock som bär ristningen inte är jordfast, utan att det har flyttats till sin nuvarande plats under vikingatiden och att det kan ha fungerat som ett inseglingsmärke i den hamn som fanns vid kungsgården. Här har vid en ännu okänd tidpunkt också anlagts en lagunhamn och kanske är det för sina insatser för att skapa denna anläggning som bryten Tole hade uppmanats av kungen att låta hugga runor till sitt och hustruns minne.</p>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">ATT HÅKON RÖDE</mark></strong> är den enda av sveakungarna vars namn har bevarats på en runsten står i bjärt konstrast till Danmark, där en hel rad av vikingatidskungarna från de historiska källorna också förekommer på runstenarna. Redan på 930-talet lät Astrid, Odenkars dotter, resa en runsten vid staden Hedeby på Sydjylland till minne »kung Sigtrygg», sin och Gnupas son. Både Sigtrygg och Gnupa är kända från annat håll och enligt Adam av Bremen ska Gnupas far Olof ha kommit från Sverige. Denna uppgift brukar inte vara överdrivet populär bland danska forskare, men Adam hade som sagesman bland annat den danske kungen Sven Estridsson, som i tolv års tid hade levt i landsflykt hos den svenske kungen Anund Jakob och det är rätt troligt att uppgiften kommer från honom.</p>


<div class="wp-block-image">
<figure class="alignright size-large is-resized"><img decoding="async" src="https://elbilen.se/wp-content/uploads/sites/3/2023/04/Bild-3_test-edited.png" alt="" class="wp-image-3309" width="399" height="710" srcset="https://elbilen.se/wp-content/uploads/sites/3/2023/04/Bild-3_test-edited.png 1084w, https://elbilen.se/wp-content/uploads/sites/3/2023/04/Bild-3_test-edited-169x300.png 169w, https://elbilen.se/wp-content/uploads/sites/3/2023/04/Bild-3_test-edited-576x1024.png 576w, https://elbilen.se/wp-content/uploads/sites/3/2023/04/Bild-3_test-edited-768x1366.png 768w, https://elbilen.se/wp-content/uploads/sites/3/2023/04/Bild-3_test-edited-864x1536.png 864w" sizes="(max-width: 399px) 100vw, 399px" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Sparlösastenen i Västergötland. Foto: Bengt A. Lundberg, Arkivsök RAÄ</mark></strong></figcaption></figure></div>


<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">SENARE UNDER 900-TALET</mark></strong> lät »kung Gorm» (Gorm en gamle) resa en run­sten till minne av sin hustru Tyra (som egentligen hette Torvi eller Tyrvi) i Jelling. Omkring 965 tog sonen »kung Harald» (Harald Blåtand) initiativet till en enorm runsten på samma plats till föräldrarnas minne, vilken också var ett monument över hans egna bedrifter att lägga under sig hela Danmark och Norge och göra danerna kristna. I början av 1000-talet satte »kung Sven» en sten till minne av en hirdman som hade dött vid Hedeby. Av allt att döma handlar det här om ytterligare en i den danska successionen nämligen Haralds son Sven, som vi annars känner som Sven Tveskägg.</p>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">ATT DET TIDIGT</mark></strong> har funnits kungar också i Sverige framgår av flera källor. Redan Tacitus omtalar i sin <em>Germania </em>från år 98 att svionerna lydde under en ensam härskare och genom inlån i finskan har till och med den urnordiska formen av ordet kung bevarats från ungefär samma tid. <em>Kuningas </em>heter det där än i dag, vilket motsvarar ett urnordiskt<em> *kuningaʀ</em>. Det äldsta runskrivna exemplet finns på Rökstenen i Östergötland, som bör tillhöra 800-talet och där det på ett par ställen talas om tjugo konungar (<em>kunungaʀ tvæiʀ tigiʀ</em>), som är söner av fyra bröder och som dessutom är namngivna på stenen:</p>



<div class="wp-block-columns is-layout-flex wp-container-core-columns-is-layout-9d6595d7 wp-block-columns-is-layout-flex">
<div class="wp-block-column is-layout-flow wp-block-column-is-layout-flow" style="flex-basis:30px"></div>



<div class="wp-block-column is-layout-flow wp-block-column-is-layout-flow">
<p><em>»Fem med namnet Valke, Rådulvs söner, fem Redulv, Rugulvs söner, fem Haisl, Hords söner, fem Gunnmund, Björns(?) söner.»</em></p>
</div>
</div>



<p>De flesta av namnen är mycket ovanliga och endast det något osäkert tolkade <em>Björn </em>annars är känt från de svenska kungaätterna. Så hette ju den kung som fanns i Birka när Ansgar gjorde sitt besök år 829. Detta är nog en ren tillfällighet och bara det faktum att bröderna inom respektive brödraskara bär samma namn talar för att vi här rör oss i sagans värld.</p>



<p>   Bo Ralph har i sin nytolkning av Rök­stenen till och med föreslagit att det inte alls handlar om några kungar, utan om en gåta om vindar från de fyra väderstrecken.</p>


<div class="wp-block-image">
<figure class="alignright size-large is-resized"><img decoding="async" src="https://elbilen.se/wp-content/uploads/sites/3/2023/04/Bild-4_test-1-edited.jpg" alt="" class="wp-image-3310" width="416" height="416" srcset="https://elbilen.se/wp-content/uploads/sites/3/2023/04/Bild-4_test-1-edited.jpg 851w, https://elbilen.se/wp-content/uploads/sites/3/2023/04/Bild-4_test-1-edited-300x300.jpg 300w, https://elbilen.se/wp-content/uploads/sites/3/2023/04/Bild-4_test-1-edited-150x150.jpg 150w, https://elbilen.se/wp-content/uploads/sites/3/2023/04/Bild-4_test-1-edited-768x768.jpg 768w" sizes="(max-width: 416px) 100vw, 416px" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Runstenen i Rimbo kyrka med kunglig <em>namngivning</em>. Foto: Magnus Källström, RAÄ</mark></strong></figcaption></figure></div>


<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">ÄVEN PÅ SPARLÖSASTENEN</mark></strong> i Västergötland, som bör ha rests senast omkring år 800, har man velat läsa kunganamn, även det här inte förekommer något ord för kung. Texten inleds med orden <em>Æivīsl gaf, Æirīks sunʀ, gaf Alrīki …</em> »Evisl gav, Eriks son, gav åt Alrik …». Längre fram i nämns att någon gav något <em>at gialdi </em>»i gengäld», men vad det var som utväxlades vet vi inte. Här förekommer också en delvis defekt runföljd, där man har velat läsa ortnamnet <em>Uppsala</em>, men i så fall i en oväntad singularform (<strong>ubsal</strong>).</p>



<p>   Namnen <em>Erik och Alrik </em>uppträder tillsammans i den genealogiska dikten Ynglingatal, som räknar upp förfäderna till en norsk småkung, men där de flesta av leden är knutna till Sverige och ofta till Uppsala. Här är Erik och Alrik två bröder som slår ihjäl varandra med sina hästbetsel i samband med en kappridning. Om denna historia verkligen har något med Sparlösastenen att göra är väl rätt tveksamt. Samtidigt har namnet <em>Erik </em>(<em>Æirīkʀ</em>) en speciell klang. Det betyder ursprungligen ’ensam härskare’ eller ’härskaren framför andra’ (urnordiska <em>*Aina-rīk(ij)aʀ</em>) och tycks under vikingatiden nästan enbart ha förekommit inom kungaätterna. Först under medeltiden får det en spridning i bredare folklager genom uppkallelse efter helgonkungen Erik den helige.</p>



<p><mark class="has-inline-color has-luminous-vivid-orange-color"><strong>I DE KUNGALÄNGDER</strong> </mark>som möter i Ynglingatal och senare också i Snorres konungasagor räknas sveakungarnas härstamning ända tillbaka till Oden och Yngve-Frej. Det mesta av detta är säkert ren dikt, även om ett och annat kan ha haft med verkligheten att göra. Att en del av kunganamnen exempelvis har sina motsvarigheter i den fornengelska dikten Beowulf ska säkert tas på allvar.</p>


<div class="wp-block-image">
<figure class="alignright size-large is-resized"><img decoding="async" src="https://elbilen.se/wp-content/uploads/sites/3/2023/02/Bild-5_test-844x1024.jpg" alt="" class="wp-image-274" width="359" height="436" srcset="https://elbilen.se/wp-content/uploads/sites/3/2023/02/Bild-5_test-844x1024.jpg 844w, https://elbilen.se/wp-content/uploads/sites/3/2023/02/Bild-5_test-247x300.jpg 247w, https://elbilen.se/wp-content/uploads/sites/3/2023/02/Bild-5_test-768x932.jpg 768w, https://elbilen.se/wp-content/uploads/sites/3/2023/02/Bild-5_test.jpg 900w" sizes="(max-width: 359px) 100vw, 359px" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Runstenen i Husby-Sjuhundra kyrka, ristad av mästaren Åsmund Kåresson. Foto: ATA</mark></strong></figcaption></figure></div>


<p>   Annars är det först när Ansgar kommer till Birka som vi får mer pålitliga upplysningar. Vid det första besöket 829 hette kungen som nämnts Björn. När Ansgar återvänder tjugo år senare har denne efterträtts av Olof. I Ansgarskrönikan skymtar också två andra sveakungar förbi: Anund som hade blivit fördriven och som återkommer för att attackera staden, och den gamle kung Erik, som efter sin död hade upphöjts till gud.</p>



<p>   Därefter dröjer det till slutet av 900-talet innan vi vågar tro lite mer på de källor som står oss till buds. Nu heter kungen Erik med binamnet Segersäll. Denne blir far till Olof Skötkonung, vilken som bekant är den förste svenske kung som låter prägla mynt med sitt namn. Däremot verkar varken han eller någon av hans söner, Anund Jakob och Emund Gamle, ha rest några runstenar.</p>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">ÅTERSTÅR ALLTSÅ DEN</mark> </strong>ovan nämnde Håkon på Hovgårdsstenen. Han antas som nämnts ha blivit kung omkring 1075 och stenens ornamentik ser ut att stämma väl överens med den historiska dateringen. Enligt Anne-Sofie Gräslunds bekanta typologi ska den placeras i 1000-talets sista tredjedel. Tiden dessförinnan har tydligen varit en mycket turbulent i Mälardalen och Adam skriver i sin historia:</p>



<div class="wp-block-columns is-layout-flex wp-container-core-columns-is-layout-9d6595d7 wp-block-columns-is-layout-flex">
<div class="wp-block-column is-layout-flow wp-block-column-is-layout-flow" style="flex-basis:30px"></div>



<div class="wp-block-column is-layout-flow wp-block-column-is-layout-flow">
<p><em> I sveonernas land avled vid samma tid [det vill säga 1066] den mycket fromme kung Stenkil. Efter honom kämpade två med namnet Erik om kungamakten, och i detta krig skall alla svenskarnas stormän ha stupat. Båda kungarna omkom också då. När hela kungasläkten sålunda var fullständigt utdöd, både ändrades förhållandena i riket och stördes kristendomen där i hög grad.</em></p>
</div>
</div>



<p>I en senare tillagd marginalanteckning ges ytterligare några uppgifter om förloppet:</p>



<div class="wp-block-columns is-layout-flex wp-container-core-columns-is-layout-9d6595d7 wp-block-columns-is-layout-flex">
<div class="wp-block-column is-layout-flow wp-block-column-is-layout-flow" style="flex-basis:30px"></div>



<div class="wp-block-column is-layout-flow wp-block-column-is-layout-flow" style="flex-basis:90%">
<p><em>  Sedan de två med namnet Erik hade stupat i striden, uppsattes kung Stenkils son Halsten på tronen. När denne snart hade blivit fördriven, tillkallades Anund från Ryssland, och sedan också han hade avsatts, valde sveonerna en viss Hakon, viken tog den unge Olavs moder till äkta.</em></p>
</div>
</div>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">UNDER EN TIOÅRSPERIOD</mark></strong> hade det alltså dels utkämpats ett inbördeskrig i Sverige, där den tidigare kungaätten hade utplånats tillsammans med alla svenska stormän, dels hade två olika kungar hunnit väljas och avsättas innan Håkon slutligen hamnade på tronen. Eftersom Adam anses ha avslutat sitt arbete i mitten av 1070-talet var detta samtidshistoria för honom och vi har all anledning att tro att framställningen speglar det verkliga förloppet. Detta sammanfaller också med den period när runstensresandet var som allra intensivast i Mälardalen. Varför ser vi inga spår av dessa händelser på runstenarna? Eller finns de kanske där?</p>



<p>   En runsten som har satts i samband med denna tid sitter inmurad i Rimbo kyrka utanför Norrtälje. Den är utförd med runristaren Torbjörn Skalds karakteristiska handlag och bär följande inskrift:</p>



<div class="wp-block-columns is-layout-flex wp-container-core-columns-is-layout-9d6595d7 wp-block-columns-is-layout-flex">
<div class="wp-block-column is-layout-flow wp-block-column-is-layout-flow" style="flex-basis:30px"></div>



<div class="wp-block-column is-layout-flow wp-block-column-is-layout-flow" style="flex-basis:100%">
<p><em>»Anund och Erik och Håkon och Ingvar reste denna sten efter Ragnar, sin broder. Gud hjälpe hans ande.»</em></p>
</div>
</div>



<p>Här ser det ut som om nästan alla tronpretendenterna skulle rymmas i en och samma brödraskara och det har även föreslagits att Ingvar skulle vara identisk med den berömde Ingvar den vittfarne, som begav sig österut med en stor flotta och förgicks i det fjärran Särkland. Det är dock svårt att få runstenstexten att gå ihop med de historiska uppgifterna. Samma brödraskara dyker nämligen också upp åtta kilometer bort på en runsten vid Husby-Sjuhundra kyrka. Texten lyder där:</p>



<div class="wp-block-columns is-layout-flex wp-container-core-columns-is-layout-9d6595d7 wp-block-columns-is-layout-flex">
<div class="wp-block-column is-layout-flow wp-block-column-is-layout-flow" style="flex-basis:30px"></div>



<div class="wp-block-column is-layout-flow wp-block-column-is-layout-flow" style="flex-basis:100%">
<p><em>»Erik och Håkon och Ingvar och Ragnhild de … Han blev död i Grekland. Gud hjälpe hans själ, och Guds moder.»</em></p>
</div>
</div>



<p>Denna sten är däremot ristad av den kände runristaren Åsmund Kåresson och bör av ornamentiken att döma tillhöra den senare delen av 1000-talet. Eftersom Ingvar fortfarande är med i leken kan det alltså inte handla om Ingvar den vittfarne, som enligt sagan ska ha dött 1041. Samtidigt saknas den äldste brodern Anund och det har därför antagits att stenen är rest efter honom. Han har i så fall mist livet nere i Bysans och kan inte gärna vara identisk med den Anund som kallades in från Ryssland för att bli kung. Dessutom påstår ju Adam att hela den gamla kungaätten hade utplånats i samband med striderna mellan de två erikarna.</p>



<blockquote class="wp-block-quote is-layout-flow wp-block-quote-is-layout-flow">
<p style="font-size:30px"><strong><mark class="has-inline-color has-luminous-vivid-orange-color">Uppenbarligen handlar det här om medlemmar av det högsta samhälls­skiktet.</mark></strong></p>
</blockquote>



<p><mark class="has-inline-color has-luminous-vivid-orange-color"><strong>ANNORLUNDA ÄR DET</strong> </mark>med Anunds bror Erik. Namnet var ju under vikingatiden nästan uteslutande förbehållet kunga­ätterna och i det runstensrika Uppland är det bara känt från en handfull inskrifter. En av dessa är den berömda Hillersjöhällen på Mälaröarna, där den förmögna änkan Gerlögs enda dotter Inga andra gången gifter sig med en Erik. Mycket talar för att det här handlar om en och samma Erik. Hällen är nämligen signerad av den ovannämnde runristaren Torbjörn Skald och måste vara ungefär samtida med stenen i Rimbo kyrka. Dessutom är det tydligt att Torbjörn på Hillersjöhällen har imiterat Åsmunds runsten vid Husby-Sjuhundra kyrka, vilket kan tyda på ett samband mellan de båda ätterna.</p>



<p>   Uppenbarligen handlar det här om medlemmar av det högsta samhällsskiktet i Uppland och det vore då närmast märkligt om inte denne Erik också skulle vara identisk med en av de erikar som på 1060-talet stred om kungamakten. I så fall har vi här identifierat en av dem som åtminstone försökte bli kung.</p>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">I TURINGE, ETT</mark></strong> par mil väster om Söder­tälje i Södermanland, fanns under samma tid en annan mäktig familj. De är bara kända genom den stora rektangu­lära runsten av röd sandsten som finns inne i Turinge kyrka. Inskriften är den längsta som har påträffats på en runsten i Södermanland och den är delvis avfattad på vers:</p>



<div class="wp-block-columns is-layout-flex wp-container-core-columns-is-layout-9d6595d7 wp-block-columns-is-layout-flex">
<div class="wp-block-column is-layout-flow wp-block-column-is-layout-flow" style="flex-basis:30px"></div>



<div class="wp-block-column is-layout-flow wp-block-column-is-layout-flow" style="flex-basis:100%">
<p><em>   »Kättil och Björn de reste denna sten efter Torsten, sin fader, Anund efter sin broder och huskarlarna efter den rättvise(?), Kättilö efter sin make.</em></p>
</div>
</div>



<div class="wp-block-columns is-layout-flex wp-container-core-columns-is-layout-9d6595d7 wp-block-columns-is-layout-flex">
<div class="wp-block-column is-layout-flow wp-block-column-is-layout-flow" style="flex-basis:30px"></div>



<div class="wp-block-column is-layout-flow wp-block-column-is-layout-flow" style="flex-basis:100%">
<p><em>Bröderna var bland de bästa män i landet och ute i ledung, de höll sina huskarlar väl. Han föll i strid österut i Gårdarike, krigarföljets hövding, av landmän den bäste.»</em></p>
</div>
</div>


<div class="wp-block-image">
<figure class="alignleft size-large is-resized"><img decoding="async" src="https://elbilen.se/wp-content/uploads/sites/3/2023/04/Bild-6_test-edited-1.jpg" alt="" class="wp-image-3312" width="305" height="488" srcset="https://elbilen.se/wp-content/uploads/sites/3/2023/04/Bild-6_test-edited-1.jpg 1079w, https://elbilen.se/wp-content/uploads/sites/3/2023/04/Bild-6_test-edited-1-188x300.jpg 188w, https://elbilen.se/wp-content/uploads/sites/3/2023/04/Bild-6_test-edited-1-640x1024.jpg 640w, https://elbilen.se/wp-content/uploads/sites/3/2023/04/Bild-6_test-edited-1-768x1229.jpg 768w, https://elbilen.se/wp-content/uploads/sites/3/2023/04/Bild-6_test-edited-1-960x1536.jpg 960w" sizes="(max-width: 305px) 100vw, 305px" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Den stora runstenen i Turinge kyrka. Foto: Bengt A. Lundberg, Arkivsök</mark></strong></figcaption></figure></div>


<p>Namnskicket är här helt annat och skulle nog snarast karakteriseras som typiska vikingatida bondenamn. Samtidigt är detta den enda runsten som nämner ordet huskarl i pluralis, vilket visar att det inte har handlat om några småbönder. Den döde Torsten sägs också vara <em>landmanna bæztr </em>»den bästa av landmän», där ordet <em>landmaðr </em>sannolikt syftade på en person som rådde över ett större landområde. Både han och brodern Anund var dessutom framgångsrika utlandsfarare. Deras sista färd gick som synes österut till Ryssland där Torsten föll i strid, medan Anund har återvänt hem och deltagit i resandet av stenen efter sin bror.</p>



<p>   Namnet <em>Anund </em>är till skillnad mot Erik mycket vanligt under 1000-talet, men om det är någon på de mälardalska runstenarna som skulle kunna kallas ”Anund från Ryssland”, så är det Turinge­stenens Anund. I så fall har ytterligare en av 1060-talets svenska kungar kunnat identifieras, även om hans tid som sådan tycks ha varit mycket kort.</p>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">ERIK OCH ANUND</mark></strong> kan ses som företrädarna för två fraktioner med säte i olika delar av Mälardalen och båda fallen i närheten av en plats med namnet Tälje. Eriks familj kan av namnskicket att döma mycket väl ha tillhört en sidogren av den gamla kungaätten. Det stora avståndet mellan deras stenar i Rimbo och Husby-Sjuhundra kyrkor tyder också på att de har haft omfattande ägor längs den vattenled som förband Norrtälje­viken med landsvägen upp till Uppsala via Mora stenar, där kungavalen hölls.</p>



<p>   Redan namnet Husby skvallrar också om en kunglig närvaro i området. Den Ragnhild som nämns på runstenen i Husby-Sjuhundra bör ha varit brödernas mor och på ytterligare ett par runstenar i samma område möter troligen namnet på en sjätte broder med det unika namnet <em>Hårok</em>. Tack vare ett lyckligt arkivfynd vet vi numera att samma brödra­skara även har rest en runsten efter sin far. Den har stått vid gården Salmunge, som ligger mycket strategiskt intill den nämnda vattenleden mitt emellan Rimbo och Husby. Bredvid stenen ska ha funnits en stor rektangulär stensättning där fadern troligen har vilat, vilket tyder på att detta har varit deras huvudgård. Vad fadern har burit för namn får vi tyvärr inte veta, eftersom det var bortslaget när stenen avbildades.</p>



<p>   Anund och hans bror Torsten, som bodde söder om Mälaren, bör också ha förfogat över stora landområden, men har även skaffat sig inkomster genom det som lite eufemistiskt brukar kallats »extern tillägnelse». Det är mycket möjligt att de av samtiden betraktades som ett par nyrika uppkomlingar och kanske var det därför som Anunds tid som kung blev så kort.</p>



<blockquote class="wp-block-quote is-layout-flow wp-block-quote-is-layout-flow">
<p style="font-size:30px"><strong><mark class="has-inline-color has-luminous-vivid-orange-color">I jakten på kungen har vi kanske också funnit en drottning.</mark></strong></p>
</blockquote>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">DEN KUNG HÅKON</mark></strong> som tog över efter honom ska däremot ha regerat över ett decennium, men vad han egentligen företog sig under denna tid är okänt. De historiska källorna är magra och delvis motsägelsefulla. Att han låter resa en runsten i hamnen vid Hovgården på Adelsö visar att han måste ha haft ett särskilt intresse för denna plats, som låg rätt långt från Sigtuna men nära det övergivna Birka på Björkö. Om nytolkningen av runföljden <strong>roþ </strong>som beteckningen på en farled eller inseglingsränna träffar det rätta så verkar han också ha vurmat för kommunikationerna i området.</p>


<div class="wp-block-image">
<figure class="alignright size-large is-resized"><img decoding="async" src="https://elbilen.se/wp-content/uploads/sites/3/2023/02/MIX-299x1024.png" alt="" class="wp-image-3313" width="364" height="1246" /></figure></div>


<p>   Vid samma tid tillkommer flera runristningar längs vattenleden ned mot dagens Södertälje, vilka alla är utförda av en runristare vid namn Östen.</p>



<p>   Förmodligen är det också han som har huggit den stora runstenen i Turinge kyrka. Hans främsta uppdragsgivare har annars varit en man vid namn Holmfast, som i ett par ristningar vid den gamla Turingevägen (numera Holmfastvägen) i Södertälje berättar att han har låtit röja vägar och bygga en bro till minne av sina föräldrar, som hörde hemma i gården Näsby mitt emellan Turinge och Södertälje. Vid viken norrut från Södertälje har Östen också utfört ett par ristningar i fast häll, vilka båda är vända ut mot vattnet och som nog bara kunde ses av de sjöfarande. En av dessa finns i vikens mynning vid berget Bornhuvud och upptäcktes så sent som i oktober 2007.</p>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">OM MAN PÅ</mark></strong> en karta drar en rät linje mellan dessa platser hamnar man på Birka, där det vid Björkö by har påträffats ytterligare en runsten av Östens hand (nu på Birkamuseet). Detta måste vara mer än en tillfällighet och en rimlig tanke är att ristningarna har ingått i ett navigeringssystem där Tälje och Birka har spelat en särskild roll. När Adam av Bremen på 1070-talet beskriver hur man tar sig landvägen från Skåne till Sigtuna över Skara, är det just dessa två platser som han nämner. Att Tälje genom landhöjningen måste ha utvecklat sig till en viktig knutpunkt mellan land- och vattenvägarna vid denna tid är helt klart, men vilken betydelse det ödelagda Birka kan ha haft i sammanhanget är svårare att förstå. </p>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">DEN ÄLDSTA KYRKAN</mark></strong> i Södertälje heter S:ta Ragnhilds kyrka och är invigd åt ett lokalhelgon som i sena källor påstås ha varit drottning och som har gifts ihop med både Inge den äldre och Inge den yngre, båda efterträdare till kung Håkon. En källa gör också gällande att hon var dotter till Halsten, alltså en av de kortlivade kungarna från det turbulenta 1060-talet som vi ännu inte har hittat på någon runsten. Källäget är väl inte direkt det bästa, men att Ragnhild har varit en historisk person vill nog de flesta hävda och man kan inte undgå att notera att hon bär samma namn som Rimbobrödernas mor. Givetvis kan det inte röra sig om samma person, men säkert om samma stormannakretsar. I jakten på kungen har vi kanske också funnit en drottning.</p>
