Ökensand och packis – eller död på Kreta


<h2 class="wp-block-heading" style="font-size:25px"><mark class="has-inline-color has-luminous-vivid-orange-color">Reseminnen från tiohundratalet</mark></h2>



<p class="has-medium-font-size"><strong>I slutet av juni 1940 gjordes en märklig upptäckt vid gården Timans i Roma mitt på Gotland. I samband med grävning för en telefonkabel påträffades ett litet bryne av sandsten som på den ena sidan bar runor med ett oväntat meddelande från vikingatiden.</strong></p>


<div class="wp-block-image">
<figure class="alignright size-large is-resized"><img src="https://elbilen.se/wp-content/uploads/sites/3/2023/04/Fig.-1.-G-216-Timans-Roma-sn-Bengt-A.-Lundberg-1024x685.jpg" alt="" class="wp-image-3386" width="490" height="327" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Det runristade brynet från Timans i Roma på Gotland. FOTO BENGT A. LUNDBERG, RAÄ ARKIVSÖK</mark></strong></figcaption></figure></div>


<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">BRYNET LÅG CIRKA</mark></strong> 40 centimeter under marken och enligt uppgift utan samband med någon synlig fornlämning. Några meter därifrån skulle upphittaren ha iakttagit ett par större stenar längre ned i marken tillsammans med benrester som han trodde kunde vara av människa. Brynet har dock knappast tillhört en grav. År 1974 hittades en silverskatt i samma åker och efterundersökningarna 1982 och 1983 visade att det här ligger en boplats från vikingatid och tidig medeltid.</p>



<p>   Inskriften på Timansbrynet består inte av mer än sex ord, men är ändå en av de mest fantasieggande som har hittats på Gotland. Man läser här i tre rader:</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:50%">
<p><strong>: ormiga : ulfua-r :<br />krikiaʀ : iaursaliʀ :<br />islat : serklat</strong></p>
</div>
</div>



<p>Den första raden innehåller är två mansnamn, <em>Ormika </em>och <em>Ulfvatr</em>. De två andra innehåller namnen på fyra geografiska platser: Grekland, Jerusalem, Island och Särkland.</p>



<p>   Det är lätt att förstå att sakkunskapen till en början var lite avvaktande inför denna inskrift som förutom namnen på de fyra länderna också innehöll personnamnet <em>Ormika </em>som tidigare bara var känt från Gutasagan. Professor Otto von Friesen i Uppsala som hade fått sig brynet tillsänt för att göra en närmare bedömning skriver till Mårten Stenberger den 6 juli 1940:</p>



<p><em>Timans-stenen kom hit på förmiddagen, och jag har studerat den med största intresse. Dess märkliga likhet med miniatyr­avbildningar i terracotta eller bränd lera av bekanta danska runstenar som funnos i handeln för 30–40 år sedan slog mig till en början. Men en närmare eftersyn gav snart vid handen att här svårligen kunde vara fråga om ett försök att göra en ”runsten”. […] Varken run- eller språkformer tyder på att här skulle föreligga en ristning från senare tider. Tvärtom pekar ett par smådrag på att ristningen har en mycket respektabel ålder.</em></p>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">RISTNINGEN BEDÖMDES ALLTSÅ</mark></strong> som äkta och denna slutsats står sig än i dag. De platser som nämns på brynet är alla belägna långt från Gotland och i utkanterna av den vikingatida världen. Samtidigt handlar det – med undantag för Island – om namn som vi inte sällan möter på de vikingatida runstenarna.</p>


<div class="wp-block-image">
<figure class="alignright size-large is-resized"><img src="https://elbilen.se/wp-content/uploads/sites/3/2023/04/Fig.-2.-Vikingafarder-STF-1949-1024x789.jpg" alt="" class="wp-image-3387" width="476" height="367" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Vikingatida resvanor som de skildrades i Svenska Turistföreningens årsskrift »Tiohundratalet» 1949.</mark></strong></figcaption></figure></div>


<p>   Allra vanligast är böjningsformer av ordet <em>Grikkiaʀ</em>, som egentligen är en folk­slagsbeteckning och betyder ’greker’. Om Gunnar från Åshusby i Norrsunda utanför Stockholm sägs att <em>hann vaʀ dauðr meðr Grikkium</em> »han blev död bland grekerna». Ofta används ordet som om det vore ett vanligt ortnamn och ett uttryck som <em>Hann dō ī Grikkium</em> ska alltså uttydas som »Han dog i Grekland». I undantagsfall möter också formen <em>Grikkland </em>på stenarna.</p>



<p>   Att Grekland då som nu var ett populärt resmål för tiohundratalets svenskar framgår av att det finns omnämnt på närmare trettio runstenar och då framför allt i Mälardalen. Statistiken är samtidigt lite deprimerande. Av de 31 personer som vi genom dessa runstenar vet gav sig i väg till Grekland var det inte mindre än 23 stycken eller 74 procent som uttryckligen dog där borta. Det handlade då inte om några vanliga semesterresor, och vikingarnas Grekland var inte heller detsamma som idag, utan det som avsågs var hela det bysantinska riket med världsstaden Konstantinopel – dagens Istanbul – som mittpunkt.</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">Att Grekland då som nu var ett populärt resmål för tiohundratalets svenskar framgår av att det finns omnämnt på närmare trettio runstenar.</mark></strong></p>
</blockquote>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">I DENNA STAD</mark></strong> residerade den bysantinske kejsaren med sin livvakt av skandinaviska krigare – det så kallade väringa­gardet. Hit sökte sig även berömdheter som den hänsynslöse Harald Hårdråde, vilken dessförinnan hade kämpat i slaget vid Stiklastad 1030 där hans halvbror kung Olav Haraldsson hade fallit och blivit helgonförklarad. Enligt Snorre ska Harald efter detta ha tagit vägen genom Sverige och det är inte orimligt att tänka sig att flera av de Greklandsfarare som möter på de mälardalska runstenarna har anslutit sig till hans följe när han passerade genom landet. En av dessa kan ha varit den ovan nämnde Gunnar från Norrsunda, vars runsten av stilmässiga skäl bör tillhöra just denna tid.</p>



<p>   För Gunnar gick det illa, medan andra lyckades bättre. Den Ragnvald som på det stora runblocket vid Kyrkstigen i Ed lät hugga en ristning till minne av sin mor Fastvi, nämner i en annan ristning på samma block att han »var i Grekland» där »han var krigarföljets hövding» (Vaʀ ā Grikklandi, vas liðs forungi). Här kan det mycket väl ha handlat om en framskjuten position i det nämnda väringagardet.</p>



<figure class="wp-block-image size-large"><img src="https://elbilen.se/wp-content/uploads/sites/3/2023/04/MIXX5-1024x594.jpg" alt="" class="wp-image-3488" /></figure>



<p></p>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">OM ETT PAR</mark></strong> sörmlänningar får vi genom runstenarna veta att de i Grekland hade »skiftat guld» (<em>gulli skifti</em>), vilket nog ska tolkas som att de har fördelat krigsbyten emellan sig. Förmodligen handlar det också om något sådant när det på run­stenen vid Ulunda vad utanför Enköping sägs om den döde:</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:50%">
<p><em>Fōr hæfila,<br />fēaʀ aflaði<br />ūt ī Grikkium<br />arfa sīnum.</em><br />»Han for dristigt,<br />förvärvade ägodelar<br />ute i Grekland<br />åt sin arvinge.»</p>
</div>
</div>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">OM MAN ENLIGT</mark></strong> den ovan nämnda run­stensstatistiken hade en chans på fyra att komma levande hem från Grekland, så var chansen vid en Särklandsresa enligt samma material obefintlig. Ingen av de män som har tillägnats de fem runstenar där Särkland nämns tycks ha kommit tillbaka. Detta hänger delvis samman med att de med ett undantag är knutna till en speciell händelse, nämligen den stora expedition som leddes av hövdingen Ingvar. Denna finns omtalad på ett 25-tal runstenar i Uppland, Södermanland, Västmanland och Östergötland och var en så anmärkningsvärd händelse att Ingvar till och med fick en egen saga på Island. Här kallas han Ingvarr hinn viðfǫrli »Ingvar den vittfarne» och ska ha haft en flotta på trettio skepp. Sagan ger dock knappast någon rättvisande bild av denna resas förlopp, inte minst med tanke på det stora inslaget av drakar och jättar. Lyckligtvis finns runstenen vid Gripsholm som är rest efter Ingvars bror Harald och som i några korta versrader berättar vad som egentligen hände:</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:50%">
<p>»De for manligen<br />fjärran efter guld<br />och österut gav<br />örnen föda.<br />De dog söderut<br />i Särkland.»</p>
</div>
</div>



<figure class="wp-block-image size-large"><img src="https://elbilen.se/wp-content/uploads/sites/3/2023/04/MIX-6-1-1024x612.jpg" alt="" class="wp-image-3489" /></figure>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">ATT »GE ÖRNEN</mark></strong> föda» var som bekant en poetisk omskrivning för att döda fiender. Särkland är i den fornvästnordiska litteraturen ett mycket vitt begrepp för avlägset belägna länder och kan syfta på såväl Nordafrika som de muslimska områdena runt Kaspiska havet, »saracenernas land». Det har föreslagits att namnet skulle innehålla ordet <em>serkr </em>’särk’ och syfta på den karakteristiska klädedräkten eller vara bildat till latinets <em>sericum </em>’silke’. Det som ingår i namnet är det dock sannolikt en ombildning av just ordet <em>saracen</em>, den beteckning som bysantin­arna använde på kalifates undersåtar. Namnet <em>Särkland </em>är inte heller exklusivt nordiskt utan verkar ha lånats in från något annat germanskt språk.</p>



<p>   Den som sökte sig till Timansbrynets tredje resmål i österled – Jerusalem – kom knappast med några krigiska avsikter utan för att som pilgrim göra bot och bättring. Så har man i alla fall tolkat uppgifterna om Östen på Brobystenen i Täby: <em>es sōtti Iōrsaliʀ ok ændaðis upp ī Grikkium</em> »som sökte sig till Jerusalem och dog uppe i Grekland.» Om han miste livet på vägen ned till det heliga landet eller på vägen tillbaka till Sverige är svårt att avgöra.</p>


<div class="wp-block-image">
<figure class="alignleft size-full is-resized"><img src="https://elbilen.se/wp-content/uploads/sites/3/2023/04/Fig.-7.-U-605-Staket-KB-e1682709992273.jpg" alt="" class="wp-image-3392" width="336" height="532" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Den numera förstörda runhällen vid Stäket om Ingerun som reste till Jerusalem. Teckning av Mårten Aschaneus. FOTO: KB</mark></strong></figcaption></figure></div>


<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">ÖSTEN VAR STORMANNEN</mark></strong> Jarlabankes farfar och det föreslagits att även hans farmor – den i dag betydligt mer kända Estrid – var med på denna färd. I den grav som med goda skäl har utpekats som hennes, låg nämligen ett silvermynt präglat i Basel i Schweiz. En av pilgrimsvägarna från Skandinavien till Jerusalem gick nämligen från Danmark över alperna och sedan vidare genom länderna längs den norra Medelhavskusten.</p>



<p>   Om Estrid verkligen gjorde denna resa får vi sannolikt aldrig veta, men att en kvinna under 1000-talet kunde ge sig ut på en sådan färd finns det otvetydiga bevis för. Det framgår bland annat av en ristning i fast häll, som en gång fanns på den västra sidan av Stäksön vid Kungsängen nordväst om Stockholm. Tyvärr sprängdes den sönder av dalkarlar redan på 1600-talet då man genom att anlägga den så kallade Dalkarlsbacken ville förbättra vägförhållandena på ön. Lyckligtvis hade antikvarien Mårten Aschaneus strax dessförinnan ritat av ristningen och tack vare honom känner vi både dess utseende och innehåll. Texten löd:</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>»Ingerun, Hårds dotter, lät rista runorna efter sig själv. Hon vill fara österut och ut till Jerusalem. Fot ristade runorna.»</p>
</div>
</div>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">ATT INGERUN KALLAR</mark></strong> sig Hårds dotter och har låtit rista till minne sig själv tyder på att hon var det enda barnet och själv utan arvingar. Förmodligen var hon också rätt välbeställd, eftersom hon har kunnat anlita den kände runristaren Fot för att göra ristningen. Ingerun hade säkert också bestämt vad som skulle hända med hennes egendom om hon inte kom tillbaka från den riskfyllda färden och det är nog inte för långsökt att anta hon avsåg att donera fädernegården till kyrkan.</p>



<p>   Jerusalem kallas på Brobystenen <em>Iōrsaliʀ</em>. Det främmande ortnamnet har här anslutits till namn som man kände igen på hemmaplan och det är till och med böjt på samma sätt som man vid denna tid böjde <em>Uppsala</em>, där den motsvarande formen är <em>Uppsaliʀ</em>. Även den första delen av namnet har omtolkats efter det inhemska ordförrådet. Här verkar man ha associerat till personnamnsförleden Iōr-, som återgår på ett ord med betydelsen ’vildsvin’! Det framgår inte minst av stavningen <strong>iaursaliʀ </strong>på Timansbrynet med den triftong som man förväntar sig i detta ord i gotländskan och som ännu lever kvar i dialekten.</p>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">DET FJÄRDE ORTNAMNET</mark></strong> som har ristats på Timansbrynet – <strong>islat </strong>– pekar i en helt annan riktning, nämligen mot nordväst och detta är faktiskt enda gången som detta namn har fästs i runor på östnordiskt område. De svenskar som besökte Island under vikingatiden var förmodligen ganska lätt räknade, även om det påstås att den Gardar som först siktade ön var av svensk börd. För gotlänningarna Ormika och Ulvvat var detta kanske den yttersta utposten i denna riktning, men de som befann lite närmare visste att det fanns bebodda trakter även bortom denna ö.</p>



<p>   Vid gården Hønen i Norderhov sogn, tre mil nordväst om Oslo, upptäcktes på 1820-talet en runsten med en ganska lång inskrift. Tyvärr försvann stenen mycket tidigt och kvar finns bara en avskrift av runorna, som dessutom är en kopia av den enda uppteckning som gjordes. I början av 1900-talet intresserade sig den uppslagsrike språkmannen Sophus Bugge för denna inskrift, där han efter några egna ändringar och kompletteringar fick fram följande text:</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:50%">
<p><em>Út ok vítt ok þurfa<br />þerru ok áts<br />Vínlandi á ísa<br />i úbygd at kómu;<br />auð má illt vega,<br />[at] døyi ár.</em></p>



<p>»De kom ud (i Havet) og over store Strækninger og trængende til Klæde at tørre sig paa og til Mad bort imod Vinland op paa Ise i Ubygden. Ondt kan tage Lykken bort, saa man dør tidlig.»</p>
</div>
</div>



<figure class="wp-block-image size-large"><img src="https://elbilen.se/wp-content/uploads/sites/3/2023/04/Fig.-8.-N-102-Honen-1024x378.jpg" alt="" class="wp-image-3393" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Den enda kända uppteckningen av runorna på Hønenstenen i Norge som antas berätta om en färd på ishavet. Efter Bugge 1902.</mark></strong></figcaption></figure>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">BUGGE TRODDE SIG</mark></strong> alltså ha funnit namnet <em>Vinland</em> i texten, även om han hade tvingats till vissa ändringar i det som hade upptecknats från stenen. Hans efterträdare Magnus Olsen menade att det i stället rörde sig om ett adjektiv <em>vindkaldr </em>’vindkall’ och att meningen var:</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>»Ut (mot vest) og fjernt (over havet), og trengende til håndklæde og mat, kom de inn (til land), op på vindkalde iser, (frem) i ubygd [d. e. Øst-Grønlands »Ubygder»]. Ondt – (den grumme skjebnes tilskikkelse) at man skal dø tidlig – kan ta lykken bort.»</p>
</div>
</div>



<p>Enligt både Bugge och Olsen handlade inskriften om en färd genom ishavet, där man hade lidit stor nöd med väta och hunger men räddat sig upp på isen. Enligt Bugges tolkning hade de först drivit långt åt väster i riktning mot Vinland, medan Olsen antog att meningen var att de lyckades nå land på Grönlands östkust genom att ta sig över de vindpinade isarna.</p>



<p>   Om det avlägsna Vinland fick också Adam av Bremen höra av den danske kungen Sven Estridsson. På andra sidan denna ö fanns, berättade kungen, inget beboeligt land »utan allt därbortom är fyllt av obefarbar is och täckt av ett omätligt mörker». Detta hade enligt Adam även den tidigare nämnde Harald Hårdråde då nyligen fått erfara: »När han med sina skepp ville utforska det nordliga havets utsträckning, höljdes inför hans ögon världens yttersta gräns i töcken, och genom att vända om lyckades han med knapp nöd undkomma avgrundens gapande svalg». Så nära hade han alltså kommit världens ände.</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">Genom att vända om lyckades han med knapp nöd undkomma avgrundens gapande svalg.</mark></strong></p>
</blockquote>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">RUNSTENAR SOM OMNÄMNER</mark></strong> Vinland finner man annars företrädesvis i usa, där paradexemplet givetvis är den ryktbara Kensingtonstenen från Minnesota, som berättar om »åtta göter och tjugotvå norrmän på upptäcktsfärd» <strong>fro : winlanþ : of : west</strong> som det står på stenen. Enligt texten ska den ha rests 1362, men ingen skulle vid denna tid ha kommit på att stava <em>Vinland </em>med en avslutande <strong>þ</strong>-runa. Man skulle visserligen kunna hävda att runan här har blivit en <strong>d</strong>-runa som i det runalfabet som bröderna Johannes och Olaus Magnus lät trycka i Rom 1554 och 1555, men då kan inskriften inte vara äldre än mitten av 1500-talet.</p>



<p>   Kensingtonstenen är nog betydligt yngre än så. Numera vet vi att det märkliga runalfabet som finns på denna sten har använts i både Hälsingland och Medelpad under den senare delen av 1800-talet. Helt nyligen har det också upptäckts att denna runvariant har spridits av en Eric Ström från Timrå, som åtminstone sedan 1860-talet bedrev en ambulerade skrivskola runt om i Mellannorrland. Den man som 1898 fann runstenen i Minne­sota kom från Forsa i Hälsingland och det är inte osannolikt att han på något sätt har kommit i kontakt med Ströms undervisning. Skulle han till äventyrs inte vara upphovsmannen till stenen så fanns det säkert andra i grannskapet som hade lärt sig denna runvariant i det gamla landet.</p>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">MEN HUR KOMMER</mark></strong> då Kreta in i sammanhanget? Om jag ska vara ärlig så var det mest en ordvits för att få till en bra rubrik och samtidigt passa på att tävla med våra vänner i väster. Kreta hette på fornvästnordiska <em>Krít</em> och <em>krít </em>är på nutida isländska också ordet för ’krita’. Öns namn finns vad vi vet ännu inte belagt på någon runsten, även om den frejdige 1800-talsprofessorn i Köpenhamn, George Stephens, ansåg sig ha funnit denna ö på en av runstenarna vid Bällsta i Vallentuna. Enligt Stephens var stenen tillägnad en »<em>Uiri-Thuf, som i Kreta</em> hade <em>getat </em>(försvarat) <em>landet</em>». På stenen står egentligen <em>þu mon i krati · kiatit lata</em>, vilket numera brukar tolkas som <em>Þȳ man ī grāti getit lāta</em> »Därför i ett sorgekväde må han besjungas». Detta har nog yttrats mer än en gång om vikingatidens resenärer.</p>
