Staffansritt och hingsthetsning

– Om man ser på hästoffret som en institution, så ger det oss en inblick i forntida skandinavisk religion, säger Anders Kaliff.


<figure class="wp-block-image size-large"><img decoding="async" src="https://elbilen.se/wp-content/uploads/sites/3/2020/12/Horses_at_Thingvellir_Iceland_7005372799-1024x513.jpg" alt="" class="wp-image-2938" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Hingsthetsning på Island. Foto: Berit Wallenberg</mark></strong></figcaption></figure>



<p class="has-medium-font-size"><strong>Är annandagens staffansritt i själva verket spåren efter en 4 000 år gammal hästkult? Nya rön ger inblick i den förkristna tron.  </strong></p>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">PÅ VISSA STÄLLEN </mark></strong>i Sverige var det ännu under 1800­-talet oro i kyrkbänkarna på annandag jul, de unga männen kunde knappt vänta på att predikan skulle ta slut. Innan prästen hunnit avsluta gudstjänsten, kastade de sig på porten och störtade ut till sina hästar. Ynglingarna satte av i full galopp till en utvald källa i trakten, för att vattna sina fålar. Eftersom dess vatten alltid porlade och aldrig frös till is, ansågs den helig. Det var av största betydelse att komma fram först och låta hästen dricka av det kraftgivande vattnet, för just den ryttarens gård skulle få nästa års bästa skörd. </p>



<p>   Denna kapplöpning kallas för staffansritt, eftersom den ägde rum på sankt Staffans dag, en nordisk variant av Stefanos, som enligt legenden var kung Herodes stalledräng. Stefanos förstod att judarnas konung fötts när han sett Betlehems stjärna avspeglas i det vatten som kungens hästar drack ur. </p>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">MEN STAFFANSRITTEN HAR </mark></strong>egentligen ingenting att göra med den helige Staffan och hans hästar, utan går tillbaka till en 4 000 år gammal indoeuropeisk tradition som innefattar både hästoffer och fruktbarhetsriter. Det menar professor Anders Kaliff och docent Terje Østigård vid Uppsala universitet i den nya boken <em>The Great Indoeuropean Horse Sacrifi ce: 4 000 Years of Cosmological Continuity from Sintashta and the Steppe to Scandinavian Skeid</em>.  </p>



<p>   – Om man ser på hästoffret som en institution, så ger det oss en inblick i forntida skandinavisk religion från bronsåldern ända fram till böndernas folktro under 1800­-talet, säger Anders Kaliff.</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">Hästfallosens uppenbara virilitet var fruktbarhet och kraft. Det fanns inget som var större och starkare.</mark></strong></p>
</blockquote>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">FRÅN SKANDINAVIEN FINNS</mark></strong> många arkeologiska exempel som visar på hästens speciella ställning i den fornnordiska kulten. På en av Sagaholmsgravens 3 500 år gamla hällbilder från bronsåldern syns exempelvis en tidelagsscen med häst. Hingsthetsningar kan man se både på hällristningar från Bohuslän och på bildstenar från Uppland och Gotland. </p>


<div class="wp-block-image">
<figure class="alignleft size-full is-resized"><img fetchpriority="high" decoding="async" src="https://elbilen.se/wp-content/uploads/sites/3/2023/03/tidelagsagaholmfran-www.shfa_.se_.jpg" alt="" class="wp-image-699" width="336" height="473" srcset="https://elbilen.se/wp-content/uploads/sites/3/2023/03/tidelagsagaholmfran-www.shfa_.se_.jpg 546w, https://elbilen.se/wp-content/uploads/sites/3/2023/03/tidelagsagaholmfran-www.shfa_.se_-213x300.jpg 213w" sizes="(max-width: 336px) 100vw, 336px" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">En av Sagaholmsgravens hällbilder föreställer en tidelagsscen med häst. FOTO: Bertil Almgren, SHFA</mark></strong></figcaption></figure></div>


<p>Att hästar offrats finns det mängder av bevis för, inte minst från Skedemosse på Öland, där omkring hundra hästar hamnat i en gammal offersjö tillsammans med människo­- och vapenoffer från romersk järnålder (F.Kr.–375 e.Kr.) och några århundraden framåt.</p>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">HÄSTAR DÖDADES OCKSÅ</mark></strong> för att läggas i gravar, det kanske mest uppseendeväckande fyndet kommer från den vikingatida Osebergsgraven i Norge. Där begravdes två kvinnor för drygt tusen år sedan i ett skepp tillsammans med 15 hästar, troligen hingstar,  som blivit både ihjälklubbade och halshuggna. </p>



<p>   Det äldsta skriftliga belägget på hästkult i Norden kommer från den romerske historieskrivaren Tacitus. I sin bok Germania som skrevs år 79, beskriver han hur germanerna håller vita hästar i heliga lundar – och hur de användes inom riten för att kunna se in i framtiden. Alla dessa exempel har enligt Kaliff och Østigård en gemensam rot. </p>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">FÖR ATT GÅ</mark></strong> till botten med hästarnas magiska  innebörd måste vi förflytta oss till stäppen norr om Svarta havet och Kaspiska havet, dit de första spåren av indoeuropéerna leder. För mellan 5 500 och 6 000 år sedan skedde något världsomvälvande bland dessa halvnomadiska herdar – de började tämja hästar. Först hölls de som mjölk­ och slaktdjur, men så småningom började man även rida på dem. I dag, när hästen mest är synonym med hobby, kan det vara svårt att förstå dess enorma betydelse. Domesticeringen av hästen innebar en revolution! Inte bara kunde herdar ha koll på stora hjordar och tillryggalägga långa sträckor på kort tid, det gick också att strida från hästryggen. </p>


<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/03/bild-3-kapad-1024x1024.png" alt="" class="wp-image-700" width="316" height="316" srcset="https://elbilen.se/wp-content/uploads/sites/3/2023/03/bild-3-kapad-1024x1024.png 1024w, https://elbilen.se/wp-content/uploads/sites/3/2023/03/bild-3-kapad-300x300.png 300w, https://elbilen.se/wp-content/uploads/sites/3/2023/03/bild-3-kapad-150x150.png 150w, https://elbilen.se/wp-content/uploads/sites/3/2023/03/bild-3-kapad-768x768.png 768w, https://elbilen.se/wp-content/uploads/sites/3/2023/03/bild-3-kapad.png 1280w" sizes="(max-width: 316px) 100vw, 316px" /></figure></div>


<p>   Men hästen hade en exceptionell betydelse utöver detta.  </p>



<p>   – I förhistorien och i den förindustriella världen var hästen något av det största och starkaste som existerade, och att tämja dessa krafter var något av det mest extrema som var möjligt att göra. Om man tämjde och kontrollerade hästen innebar det också att man kontrollerade kosmiska krafter av övernaturlig karaktär. Hästfallosens uppenbara virilitet var fruktbarhet och kraft, den var inte symbol för något i postmodernistisk anda. Det fanns helt enkelt ingenting som var större och starkare än en fallos, säger Terje Østigård.</p>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">INDOEUROPÉERNAS INSTÄLLNING TILL</mark></strong> tämjning kommer till uttryck i att samma ord användes för ”tämja” och ”våldta”. Hur ska man förstå det? </p>



<p>   – Det är självklart ett våldsamt uttryck för manlig dominans, men också ett fysiskt sätt att kontrollera livgivande krafter i naturen. Hästens mäktiga kraft blir passiviserad och underkastad människorna, det vill säga mannen, och samma sak gäller kvinnan och hennes fruktbarhet, menar Terje  Østigård. </p>



<p>   För indoeuropéerna var det viktigt att kontrollera både hästens vilja och sexuella kraft, vilket som vi ska se skedde genom ritualer och offer. Sådana handlingar ansågs främja fruktbarheten hos såväl  djur, människor och grödor. Med hästens hjälp började indoeuropéerna erövra nya områden. </p>



<p>   Vissa drog västerut och gav för omkring 4 800 år sedan upphov till den snörkeramiska kulturen i Central­ och Nordeuropa. I Sverige kallas samma period för stridsyxekultur. Andra indoeuropéer satte sig på hästryggen och begav sig mot söder. DNA­-studier bekräftar den gamla bilden av att indoeuropéerna så småningom invaderade nordvästra Indien för mellan 4 000 och 3 500 år sedan. </p>


<div class="wp-block-image">
<figure class="alignleft size-large is-resized"><img decoding="async" src="https://elbilen.se/wp-content/uploads/sites/3/2020/12/bild-3-kapad-2-1024x1024.png" alt="" class="wp-image-701" width="305" height="305" srcset="https://elbilen.se/wp-content/uploads/sites/3/2020/12/bild-3-kapad-2-1024x1024.png 1024w, https://elbilen.se/wp-content/uploads/sites/3/2020/12/bild-3-kapad-2-300x300.png 300w, https://elbilen.se/wp-content/uploads/sites/3/2020/12/bild-3-kapad-2-150x150.png 150w, https://elbilen.se/wp-content/uploads/sites/3/2020/12/bild-3-kapad-2-768x769.png 768w, https://elbilen.se/wp-content/uploads/sites/3/2020/12/bild-3-kapad-2.png 1279w" sizes="(max-width: 305px) 100vw, 305px" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Ashvamedha avbildad på guldmynt från 300­-talet f.Kr. FOTO: Wikipedia</mark></strong></figcaption></figure></div>


<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">HÄR UPPKOM</mark></strong> ”Det stora hästoffret” kallat <em>ashvamedha</em>. Riten är kanske mest känd för att den offrade hästens fallos slutligen hamnar i drottningens säng, där hon förväntas kopulera med lemmen. Men kulten var betydligt mer komplicerad än så och handlade för kungen om att sona sina synder <em>(mahabarata)</em> och säkra fruktbarheten <em>(ramayana)</em>.</p>



<p>   Ashvamedha började med att en hingst valdes ut, som fritt fick ströva omkring under ett år. Alla de riken som hästen tog sig fram i var kungen tvungen att erövra. Riten avslutades med ett enormt offer, där hundratals djur satte livet till. Höjdpunkten på offerfesten var när den gudomliga hingsten dödades. Förhoppningen var att fruktbarheten skulle säkras i hela riket, vilket kom till uttryck i scenen med drottningen och hästlemmen.</p>



<p>   Ashvamedha är dokumenterat i texter som kan  dateras till omkring 500 f.Kr–300 e.Kr. Det är därmed en relativt sen tradition och ska ses som en självständig historisk utveckling i just Indien. I Norden tog sig hästkulten andra uttryck. </p>



<p>   – I ashvamedha har drottningen sex med en hästfallos, men flera forskare menar att den ursprungliga ritualen var en man/kung som hade sex med ett  sto – och det är just det som avbildas på hällristningar under bronsåldern. Men dessa avbildningar är cirka 1 000 år äldre än ashvamedha, som exempel  kan nämnas Sagaholmsgraven som är från 1500 f.Kr. Därför kan man spåra en mer genuin och äldre tradition i Skandinavien, menar Anders Kaliff. </p>



<figure class="wp-block-image size-large"><img decoding="async" width="1280" height="800" src="https://elbilen.se/wp-content/uploads/sites/3/2023/05/Haggebystenen-kopia-edited.jpg" alt="" class="wp-image-3640" srcset="https://elbilen.se/wp-content/uploads/sites/3/2023/05/Haggebystenen-kopia-edited.jpg 1280w, https://elbilen.se/wp-content/uploads/sites/3/2023/05/Haggebystenen-kopia-edited-300x188.jpg 300w, https://elbilen.se/wp-content/uploads/sites/3/2023/05/Haggebystenen-kopia-edited-1024x640.jpg 1024w, https://elbilen.se/wp-content/uploads/sites/3/2023/05/Haggebystenen-kopia-edited-768x480.jpg 768w" sizes="(max-width: 1280px) 100vw, 1280px" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Kan det vara en skeidstång som mannen till höger håller i på denna hingsthetsningsscen på en bildsten från Häggeby, Uppland? </mark></strong><br /><strong><mark class="has-inline-color has-black-color">Foto: Wikipedia</mark></strong></figcaption></figure>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">DE SKANDINAVISKA RITER</mark></strong> som sätts i samband med hästar kallas för skeid. Sådana är väl dokumenterade i skriftliga källor, eftersom de på vissa ställen, som i norska Setesdal, pågick långt in på 1800­talet. I samband med skörden hölls en stor gemensam träff, där folk dansade, sjöng och drack. Männen tävlade mot varandra i exempelvis brottning, löpning och längdhopp. Men höjdpunkten stod hästarna för. Dels ägde våldsamma kapplöpningar rum till en helig källa, dit det gällde att komma först för att hästen skulle få dricka av det livgivande vattnet. Dels ägde hingsthetsningar rum. De gick ut på att ett sto leddes fram och ställdes med baken mot två hingstar, som upphetsade av denna syn började slåss med varandra. För att röja sin rival ur vägen sparkade hästarna bakut, slog med sina framhovar och bet varandra. Som skydd för märren stod en modig man med en stång i handen och motade bort hingstarna. </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">Eftersom hästen var störst och mäktigast, så var hingsthetsningen också ett sätt att aktivera kosmiska krafter i naturen.</mark></strong></p>
</blockquote>



<p>   När en av hingstarna gett upp var det dags att leda in en ny motståndare till vinnarhingsten. Och så fortsatte slagsmålet ända tills att en segrande  hingst fanns kvar. Denne fick, troligen inför allas åskådan, betäcka stoet. Det föl som sedan föddes ansågs vara gudomligt. Det hände att vissa av hingstarna fick men för livet under dessa hetsningar – trots att djuren var det dyrbaraste som bönderna ägde. Ändå var det värt det, enligt principen att om man kunde tygla hästens enorma krafter så kunde människan genom ritualer också kontrollera och övervinna naturens krafter. </p>


<div class="wp-block-image is-style-default">
<figure class="alignright size-large is-resized"><img decoding="async" src="https://elbilen.se/wp-content/uploads/sites/3/2023/03/hingsthetsning-1024x621.jpg" alt="" class="wp-image-703" width="418" height="254" srcset="https://elbilen.se/wp-content/uploads/sites/3/2023/03/hingsthetsning-1024x621.jpg 1024w, https://elbilen.se/wp-content/uploads/sites/3/2023/03/hingsthetsning-300x182.jpg 300w, https://elbilen.se/wp-content/uploads/sites/3/2023/03/hingsthetsning-768x466.jpg 768w, https://elbilen.se/wp-content/uploads/sites/3/2023/03/hingsthetsning.jpg 1333w" sizes="(max-width: 418px) 100vw, 418px" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Hingsthetsning, Island. FOTO: Berit Wallenberg</mark></strong></figcaption></figure></div>


<p>   – Eftersom hästen var störst och mäktigast, så var hingsthetsningen också ett sätt att aktivera kosmiska krafter i naturen. Det var kylan och vintern som skulle övervinnas med hingsthetsning och kapplöpningar, säger Terje Østigård.</p>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">SKEID ÄR SAMMA</mark></strong> ord som dyker upp i förleden av  Skedemosse, vilket är namnet på den öländska offersjö som undersöktes arkeologiskt på 1960-talet. Vid en av hästarna hittades en lång trästång som kan tolkas som den skeidstång som användes för att hålla hingstarna borta från stoet. Arkeologen Ulf Erik Hagberg, som ledde utgrävningen, kopplade ihop platsen med just skeidtraditionen.</p>



<p>   Hingsthetsning antyds också i Ibn Fadlans beskrivning av en vikingahövdings begravning i dagens Ryssland under 900-talet. I samband med den tvingades en slavflicka ha sex med var och en av den avlidne hövdingens närmsta män, innan hon både stryptes och höggs till döds. Dessutom drev man två hästar så att de blev alldeles svettiga innan man högg dem i stycken med ett svärd.</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/03/staffan-stalledrang-Dadesjo-foto-shm.jpg" alt="" class="wp-image-705" width="352" height="560" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Staffan vattnar sina fålar i den medeltida Dädesjö kyrka, Småland. Foto: SHM</mark></strong></figcaption></figure></div>


<p>   – Att hästarna svettas innan de blev offrade kan indikera en hingsthetsning eller tävling, det vill säga skeid. Detta, tillsammans med våldtäkten/det sexuella offret av en kvinna, kan ses som två aspekter som knyter begravningen till en ”prototyp” av det indoeuropeiska hästoffret, säger Anders Kaliff. </p>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">KAPPLÖPNINGAR OCH HINGSTHETSNINGAR</mark></strong> levde parallellt med kristendomen under tusen år i Skandinavien, men till sist fick prästerna nog. Från Flistad i Östergötland kan vi hämta ett tydligt exempel på hur det kunde gå med de tidigare så heliga källorna och hästkulten. Sankt Stefanos (Staffan) är skyddshelgon för Flistads 1100-talskyrka och på den medeltida altartavlan kan man än idag se helgonet sittande på sin häst. I kyrkan fanns tidigare också en skulptur där församlingsborna ända in till mitten av 1700-talet offrade mynt och småsaker för att få bättre ”hästlycka”. Men på 1700-talet fick kyrkoherden Andreas Duræus nog och tog bort belätet. Han ville också få slut på det vidskepliga användandet av en källa, som ligger belägen på gården Lund i samma by – han hade väl fått nog av staffansritten. Källan rensades och blev i stället en hälsobrunn. Flistads gamla hästkult understryks av namnet på en annan gård i byn, nämligen Lekslätt. Lek är ett gammalt ord för riter, tävlingar och festligheter – och enligt den lokala traditionen har just  hästtävlingar ägt rum på slätten här. </p>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">I UPPLYSNINGENS OCH</mark></strong> kristendomens kölvatten upphörde så småningom dessa urgamla fruktbarhetsriter som kopplas till hästar. Vid förra sekelskiftet var både staffansritternas och hingsthetsningarnas tid över i Skandinavien – efter 4 000 år i  fruktbarhetens förmodade tjänst.</p>
