Bland runristare och skalder i vikingatidens Sigtuna


<figure class="wp-block-image size-large"><img src="https://elbilen.se/wp-content/uploads/sites/3/2021/05/shutterstock_243310558-1024x683.jpg" alt="" class="wp-image-1311" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Sankt Olof – en av Sigtunas många kyrkor – är vigd åt den norske helgonkungen, samme Olof Haraldsson som en gång hade synpunkter på Ottar Svartes diktkonst. Foto: shutterstock</mark></strong></figcaption></figure>



<p class="has-medium-font-size"><strong>Minst tre isländska skalder har besjungit ankomsten till Sigtuna – andra ristade sina verser med runor för att skrämma tjuvar och bota sjukdomar. I stadens jord finns spår av både glömd poesi och svunnen musik.</strong></p>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">ÅREN 1044–45 BEFANN</mark></strong> sig den hårdföre vikingahövdingen Harald Hårdråde på hemfärd till Norge efter sin mer än tio år långa och mycket våldsamma vistelse hos den bysantinske kejsaren i Konstantinopel. Färden har beskrivits av den isländske skalden Valgard från Völl i ett kväde, där den senare delen av den femte strofen lyder:</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:66.66%">
<p><em>stýrðir hvatt í hǫrðu<br />hvardyggr jǫfurr glyggvi<br />sátt þás sædrif létti<br />Sigtún, er skip hnigðu.</em></p>



<p>Eller som Otto v. Friesen har översatt det:</p>



<p>»Mångbeprövad hövding, du styrde<br />käckt genom hårda stormen; skeppen<br />satte i böljorna; men när sjögången<br />lättade, såg du Sigtuna.»</p>
</div>
</div>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">DET FINNS YTTERLIGARE</mark></strong> två skaldestrofer där Sigtuna nämns och i båda fallen handlar det om hur man sjövägen närmade sig staden. Förmodligen var detta det vanligaste sättet att nå denna plats, särskilt när man kom från utlandet.</p>



<p>   Minst tre isländska skalder har alltså besjungit ankomsten till Sigtuna. Förutom den ovan nämnde Valgard från Völl handlar det om Arnor Tordsson och Tjodolv Arnorsson. Alla tre var verksamma vid mitten av 1000-talet, alltså vid vikingatidens slut. Eftersom skalderna ofta reste i kungars och hövdingars följe är det mycket möjligt att de själva har besökt Sigtuna och att skildringen bygger på självsyn. Säkerligen är de inte heller de enda vikingatida skalder som har uppehållit sig i staden. Islänningarna Ottar Svarte och Gissur Svarte, som uppges ha varit hirdmän hos Olof Skötkonung och som båda har tillägnat honom kväden, bör rimligtvis ha varit där.</p>


<div class="wp-block-image">
<figure class="alignright size-full is-resized"><img src="https://elbilen.se/wp-content/uploads/sites/3/2021/05/Olav_den_helliges_saga_-_Skalden_Berse_-_C._Krogh.jpg" alt="" class="wp-image-1301" width="411" height="368" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Berse Skaldtorvasson – en annan skald som fick dikta sig till frihet från Olof Haraldsson. Teckning: Christian Krogh 1899</mark></strong></figcaption></figure></div>


<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">ENLIGT SNORRE I</mark></strong> Heimskringla ska Ottar och Gissur ha varit mycket uppskattade av kung Olof, eftersom de var <em>máldjarfir </em>det vill säga frimodiga i sitt tal och de satt ofta mittemot högsätet i samtal med honom. Ottar Svarte diktade enligt uppgift också ett kväde till Olof Skötkonungs dotter Astrid, som både ska innehållit ero­tiska undertoner och vissa skrytsamma inslag. Astrid blev senare gift med kung Olof Haraldsson i Norge. Denne gillade inte alls det han hade hört om kvädet och när Ottar kom till Norge blev han direkt gripen och kastad i fängelse. På inrådan av sin morbror, den berömde skalden Sigvat Tordsson, ska han då ha ändrat vissa opassande ordvändningar i det ursprungliga kvädet och diktade dessutom en lång hyllningsdikt till kungen. Den senare fick namnet <em>Hǫfuðlausn </em>’huvudlösen’, eftersom det var tack vare den som Ottar fick behålla sitt huvud. Att vara <em>máldjarfr</em> kunde uppenbarligen också ha sina baksidor i kungligt sällskap.</p>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">DET ÄR GIVETVIS</mark></strong> omöjligt att veta hur mycket av detta som bygger på äkta tradition och vad som är uppdiktat, men säkerligen har det skapats och framförts mycket poesi i miljön kring kungen och förmodligen också på andra platser i Sigtuna. I dag återstår endast brottstycken av denna litteratur i avskrifter av avskrifter. Vikingatiden var ännu till övervägande del ett muntligt samhälle, där berättelser och poesi bevarades i minnet och spreds genom att gång på gång reciteras och memoreras.</p>



<p>   Samtidigt fanns ju också runskriften och ett och annat har säkerligen skrivits ner, men även här har det mesta skattat åt förgängelsen. Genom en lycklig slump har dock ett litet stycke av den typ av poesi som florerade i miljön kring sveakungen, bevarats i original från just Sigtuna.</p>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">I AUGUSTI 1911</mark></strong> hittade tapetseraren Fredrik Haglund ett märkligt föremål när han grävde i trädgården till det som då var stadskvarteret nr 22-23-24 i Sigtuna. Det rörde sig om en koppardosa, som med sitt innehåll ska ha vägt nära två kilo. Det som låg i dosan ska enligt hans beskrivning närmast ha liknat grov kaffesump med små metallbitar i och varit omgivet av ett hölje som påminde om bränt papper. Tyvärr hamnade innehållet på sophögen, men själva dosan letade sig så småningom till Historiska museet i Stockholm, där man gjorde en intressant upptäckt. Längs kanten av dosan fanns två rader med fint inristade runor.</p>



<p>   Otto von Friesen, som var professor i nordiska språk vid Uppsala universitet, tillkallades och redan året efter publicerade han en läsning och tolkning av den märkliga inskriften. Den första raden avslöjade både vem som hade ägt föremålet, hur det hade kommit i hans ägo och vad det kaffesumpsliknande innehållet hade bestått av:</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:40%">
<p><em>Diarfʀ fikk af sæmskum manni skālaʀ þessaʀ ī …-landi. </em> <em>En Værmundr fāði rūnaʀ þessaʀ.</em></p>



<p>»Djärv fick dessa skålar av en man från Samland (eller Semgallen) i …-land. </p>



<p>Värmund ristade dessa runor.»</p>
</div>
</div>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">DE »SKÅLAR» SOM</mark></strong> Djärv hade förvärvat syftar på en hopfällbar våg, som handelsmän använde för att väga upp betalningssilver. Det var alltså en sådan som hade legat i dosan. Den man som Djärv hade fått skålarna av – en<em> sæmskʀ maðr</em> – kom från andra sidan Östersjön, antingen från Samland, vilket motsvarar området kring dagens Kaliningrad, eller från Semgallen, som är ett landskap i Lettland. Ursprungligen har det också funnits en uppgift i vilket land det hela tilldrog sig, men just här är tyvärr runorna helt bortvittrade.</p>



<p>   Det märkligaste är dock den andra raden med runor, som lyder:</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:40%">
<p><em>Fugl vælva slæit fǫlvan<br />fann gauk ā nās auka.</em><br />»Fågeln sönderslet den likbleke rövaren. Man märkte på asgöken hur den svällde.»</p>
</div>
</div>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">DETTA UTGÖR TVÅ</mark></strong> rader av en dikt avfattad på det komplicerade versmåttet dróttkvætt. I detta versmått ska varje rad innehålla sex stavelser och orden i raderna ska allitterera med varandra med två s.k. stuðlar i udda rader och en <em>hǫfuðstafr </em>i jämna. På Sigtunadosan är det orden på f- som uppbär allitterationen: <em><strong>f</strong>ugl – <strong>f</strong>ǫlvan – <strong>f</strong>ann.</em> Dessutom ska raderna innehålla assonanser dvs. rim i mitten av orden: helassonanser – med identiska vokaler – i jämna rader (här <em>g<strong>auk</strong> : <strong>auk</strong>a</em>) och halvassonanser – med olika vokaler – i udda (<em>vælva : fǫlvan</em>). För att följa dessa regler tillät man sig en i stort sett fri ordföljd, vilket gör att denna typ av verser många gånger kan vara minst sagt svåra att förstå.</p>


<div class="wp-block-image">
<figure class="alignleft size-large is-resized"><img src="https://elbilen.se/wp-content/uploads/sites/3/2023/03/Sigtunadosan-Foto-Bengt-A.-Lundberg-1991_1-edited.jpg" alt="" class="wp-image-1376" width="421" height="315" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Sigtunadosan. Foto: Bengt A. Lundberg/Kulturmiljöbild</mark></strong></figcaption></figure></div>


<p>   Innehållet i det lilla versparet kan förefalla något bisarrt, men förmodligen är det en sorts varning till den som eventuellt tänkte lägga vantarna på det dyrbara föremålet. Tjuven ska dö och hans lik förtäras av rovfåglar. <em>Nās gaukʀ</em> ’likets gök’ är en omskrivning – en så kallad <em>kenning </em>– för ett sådant djur. Mycket märklig är förekomsten av ordet <em>vælvi </em>’rövare’. Detta ord är annars okänt i nordiska språk, men finns i formen <em>wilwa </em>belagt i gotiskan. Av allt att döma rör det sig om ett mycket ålderdomligt ord, som förmodligen var ovanligt redan då och som kanske bara användes inom poesin. Hade det inte kommit att ristas på ett föremål som sedan hamnade i Sigtunas jord, skulle vi aldrig ha vetat att det en gång hade tillhört det svenska språket.</p>



<p>   Inskriften på Sigtunadosan är finpoesi, sådant som reciterades för kungar och hövdingar, även om det är känt att skickliga skalder också kunde slänga ur sig bitska kommentarer på samma versmått – så kallade <em>lausavísur </em>– i vitt skilda sammanhang och tydligen på stående fot.</p>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">VI HAR DOCK</mark></strong> även spår av betydligt enklare och folkligare poesi. På ett revben, som framkom i ett vattensavsatt kulturlager från en utgrävning 1994 i kvarteret Professorn 4, finns en lång besvärjelse, som av allt att döma är avfattad på vers. Versmåttet är snarast en form av fornyrðislag, samma versmått som förekommer i den berömda Tjodrikstrofen på Rökstenen, men också på många yngre runstenar. Här är det viktiga att varje versrad har två betonade stavelser och att raderna binds samman parvis genom allitteration.</p>



<p>   Den delvis svårtolkade inskriften kan återges på detta 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:66.66%">
<p><em>Iorils ōvrið<br />vaxna ūʀ Krōki!<br />Bant hann riðu,<br />barði hann riðu.<br />Ok siða sarð<br />sāra-rann(?) vara.<br />Hafiʀ fullt fengit.<br />Flȳ braut, riða!</em></p>
</div>
</div>



<p>Tydligen handlar det om en besvärjelse mot en sjukdomsdemon, som ska drivas ut ur en person med namnet Krok. »Band han febern, slog han febern» står det exempelvis i den tredje och fjärde raden och texten avslutas med uppmaningen: »Fly bort, feber!». Samtidigt innehåller inskriften flera ord som vi inte känner från annat håll, men som vi kan rekonstruera utifrån olika källor. <em>Iorill </em>är tro­ligen namnet på den sjukdomsalstrande demonen och kan innehålla ett mycket gammalt ord för ’vatten, vätska’, som bl.a. ingår i ortnamnet <em>Jörlanda </em>i Bohuslän. Runföljden <strong>ouriþ</strong> tror jag kan återge ett ord med betydelsen »ont, övernaturligt vred» och syfta på en magåkomma. Dunklast är dock de rader som med runor skrivs <strong>aok</strong> × <strong>siþa </strong>× <strong>sarþ </strong>× <strong>sararan </strong>× <strong>uara</strong>. Ordet <strong>siþa </strong>kan motsvara ett abstrakt substantiv med betydelsen ’sejdandet’. Det följande sarþ måste vara en form av verbet <em>serða</em>, som dock har en betydelse som inte alls ser ut att passa i sammanhanget, nämligen ’könsligt umgänge’ och då gärna med någon av samma kön eller med förnedrande inslag. Men vad betyder <strong>sararan </strong>× <strong>uara </strong>som i så fall borde vara objektet? Enligt ett förslag döljer runorna en kenning <em>sāra-rann vara</em> ’varets sårhus’, vilket antagits syfta på någon form av böld. Men hur ska detta kunna stå som objekt till verbet <em>serða</em>?</p>



<figure class="wp-block-image size-large"><img src="https://elbilen.se/wp-content/uploads/sites/3/2021/05/Professorn-4-framsida-1-1024x201.jpg" alt="" class="wp-image-1379" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Feberbenet från Sigtuna, som först försågs med besvärjande runor och sedan kastades långt ut i vattnet. Foto: Bengt A. Lundberg/Kulturmiljöbild</mark></strong></figcaption></figure>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">BENET FRÅN SIGTUNA</mark></strong> döljer ännu många hemligheter, men visar hur runor och poesi har kunnat användas i läkekonstens tjänst. Ett annat exempel är det bekanta Sigtunablecket som 1931 hittades i kvarteret Granhäcken i den östra delen av staden och där inskriften på samma sätt är riktad mot en sjukdomsdemon. Här talas inledningsvis om <em>Þurr sārriðu, þursa drōtinn, flȳ þū nū, fundinn es(t)</em> »Sårfeberns böld, trollens furste, fly du nu, funnen är du!». Det ord som här används för böld är troligen samma utdöda ord som har bevarats i ortnamn som t.ex. <em>Långtora </em>utanför Enköping och som har kunnat beteckna förhöjningar i landskapet. Ordet <em>sārriða </em>»sårfeber» har identifierats med barnsängsfeber, en fruktad infektionssjukdom. Detta visar att ägaren av amuletten har varit en kvinna, som skulle skyddas mot denna sjukdom.</p>



<p>   En fras i texten känner vi direkt igen från eddadiktningen, nämligen <em>þursa drōtinn</em> »trollens furste». När Tor i den berömda dikten Trymskvida hade frånstulits sin hammare och Loke skickas iväg i Frejas fjäderhamn till Jotunheim för att leta efter den, är jätten Trym den första han möter. Om denne berättar dikten:</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:66.66%">
<p><em>Þrymr sat á haugi,<br />þursa dróttinn,<br />greyjum sínum<br />gullbǫnd sneri<br />ok mǫrum sínum<br />mǫn jafnaði.</em></p>
</div>
</div>



<p>Jätten, som här sitter på högen och tvinnar guldband åt sina hundar och kammar manarna på sina hästar, får epitetet <em>þursa dróttinn</em>, »trollens» eller »jättarnas furste». Förmodligen har detta varit något av en poetisk kliché, som skalden kunde tillgripa när det behövdes en fras som allittererade på <em>þ-</em>.</p>



<figure class="wp-block-image size-large"><img src="https://elbilen.se/wp-content/uploads/sites/3/2023/03/Sigtunablecket-edited-e1681913822573-1024x409.jpg" alt="" class="wp-image-1380" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Stockholm, Sigtuna, Sigtuna, Uppland, Fornminnen-Ristningar, h‰llmÂlningar och minnesm‰rken-Runristning/runsten</mark></strong></figcaption></figure>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">DET ÄR DOCK</mark></strong> inte bara poesi och magi som har bevarats i Sigtunas djupa kulturlager utan vi har faktiskt också spår av musik, hur konstigt det än kan låta. I samband med de arkeologiska undersökningarna i kvarteret Professorn 1 år 1999 påträffades något så unikt som en stämnyckel av horn. Denna har runor på alla fyra sidor och troligen börjar texten på den ena smalsidan:</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:66.66%">
<p><em>Høyr þū hværr hitta giærði.<br />»Hör du vem som gjorde detta.»</em></p>
</div>
</div>



<p>Detta kan i den moderna översättningen se ut som en fråga, men det är en uppmaning till läsaren att lyssna. Texten fortsätter på den ena bredsidan:</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:66.66%">
<p><em>Ærri <strong>sliþi </strong>harpu þessi hæilum hǫndum.<br /></em>»Ärre <strong>sliþi </strong>denna harpa med lyckosamma händer.»</p>
</div>
</div>



<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">Kanske rör det sig om en lönnskrift med något ännu förborgat meddelande.</mark></strong></p>
</blockquote>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">SOM FRAMGÅR AV</mark></strong> inskriften har stäm­nyckeln tillhört en harpa. Mansnamnet <em>Ärre </em>är även känt från en västgötsk runsten och betyder ungefär ’den raske’ eller ’den häftige’. Vad det följande <strong>sliþi </strong>som ju borde återge ett verb står för vet vi däremot inte. Detta är ännu ett av dessa tidigare okända ord som dyker upp i runinskrifterna från Sigtuna. Möjligen hänger det samman med ett äldre svenskt verb, <em>slida</em>, som betyder ’glida, halka’ och kanske har det med stämningen eller kanske trakterandet av harpan att göra. Ett ”Ärre må smeka(?) denna harpa med lyckosamma händer” skulle ju ge en god mening, men under medeltiden användes istället verb som <em>slå </em>eller <em>leka </em>för att beskriva någon som spelade på harpa.</p>



<p>   Frasen <em>hæillum hændum</em> »med lyckosamma händer» känner vi faktiskt från en annan runinskrift. På ett medeltida järnbeslag från Telemark i Norge kan man läsa:</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:66.66%">
<p><em>Árni Þorsteinssonr gerði mik, en Háleikr Gautasonr á mik. Heilum hǫndum geri hann svá. Þetta var ristit sunnudag nær kveldi.</em><br />»Arne Torstensson gjorde mig, men Hålek Götesson äger mig. Med lyckliga händer må han göra så. Detta var ristat en söndag mot kvällen.»</p>
</div>
</div>



<figure class="wp-block-image size-large"><img src="https://elbilen.se/wp-content/uploads/sites/3/2021/05/MIXBILD-3-1024x522.jpg" alt="" class="wp-image-1381" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Stämnyckeln som skvallrar om förlorade harpotoner och frestar med gåtfulla lönnrunor. Foto: Bengt A. Lundberg/Kulturmiljöbild</mark></strong></figcaption></figure>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">STÄMNYCKELN FRÅN SIGTUNA</mark></strong> har runor på ytterligare två sidor, men dessa har inte kunnat tydas och det är oklart vilken mening de kan ha haft. När denna inskrift var alldeles nyfunnen undervisade jag i runologi på Stockholms universitet och Helmer Gustavson vid Runverket faxade mig sina nygjorda teckningar så att jag kunde visa den för studenterna. Någon föreslog då halvt på skämt att de obegripliga runorna kunde vara noter och det kanske inte är så dumt. Vi vet ju inte om eller hur man eventuellt noterade musik på vikingatiden eller ens hur en vikingatida harpa såg ut i detalj. Å andra sidan ser notationen lite väl komplicerad ut för att detta förslag ska verka helt sannolikt. Kanske rör det sig i stället om en lönnskrift med något ännu förborgat meddelande, som väntar på att tydas. När det gäller runor från Sigtuna är sällan det sista ordet sagt!</p>
