Brutale Birger


<h2 class="wp-block-heading" style="font-size:25px"><mark class="has-inline-color has-luminous-vivid-orange-color">EN TUFF UTMANING ATT ÅTERSKAPA BIRGER JARL</mark></h2>



<p class="has-medium-font-size wp-block-paragraph"><strong>– År 2009 fick jag den hedersamma frågan om jag ville rekonstruera Birger jarls ansikte till Medeltidsmuseet i Stockholm, berättar ansiktsrekonstruktören och konstnären Oscar Nilsson. En historisk kändis får man nog säga! Men Birger jarl var lika mycket ökändis som kändis.</strong></p>


<div class="wp-block-image">
<figure class="alignright size-full is-resized"><img src="https://elbilen.se/wp-content/uploads/sites/3/2023/02/Bild-1_test.jpg" alt="" class="wp-image-205" width="387" height="534" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Birgers stenporträtt i Varnhems klosterkyrka. FOTO: Axel Forssén</mark></strong></figcaption></figure>
</div>


<p class="wp-block-paragraph"><strong><mark class="has-inline-color has-luminous-vivid-orange-color">SVEAKUNGARNA HADE SEDAN</mark></strong> 1060-talet suttit löst på tronen. 1100-talet och det tidiga 1200-talet kännetecknades som bekant av växlingarna mellan sverkerska och erikska kungar. Redan från 1170-talet gled Birgers östgöta­släktingar in som en stabiliserande rad av jarlar vid kungarnas sida. Birger föddes omkring år 1210, gifte sig på 1230-talet med den siste erikske kungen Erik Erikssons syster Ingeborg och utmärkte sig som jarl från det sena 1240-talet. </p>



<p class="wp-block-paragraph">   Han ledde bland annat ett korståg till Finland sommaren år 1249. Birger är också känd för att ha grundat Stockholms stad vid mitten av 1200-talet, men det handlar snarare om att han byggde ut borgen vid den gamla ledungsplatsen. Sin största insats gjorde han dock inrikespolitiskt när han upprepat besegrade upproriska sveastormän. De hade av tradition en stark självständig ställning gentemot kungamakten eftersom de kontrollerade ledungen.</p>



<p class="wp-block-paragraph"><strong><mark class="has-inline-color has-luminous-vivid-orange-color">GENOM ÖPPEN STRID</mark>,</strong> svek och inte minst halshuggningar dämpade Birger svearnas upprorsanda. Ledungens betydelse försvagades genom att ledungsplikten ersattes med stående skatter. Denna verksamhet fullbordades av sonen Magnus Ladulås, genom några avslutande halshuggningar och Alsnö stadga år 1280. </p>


<div class="wp-block-image">
<figure class="alignright size-full is-resized"><img src="https://elbilen.se/wp-content/uploads/sites/3/2023/02/Bild-2..png" alt="" class="wp-image-207" width="325" height="296" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Birgers silvermynt är tolv millimeter i diameter. FOTO: Kenneth Jonsson</mark></strong></figcaption></figure>
</div>


<p class="wp-block-paragraph">   Vi vet inte så mycket om privatpersonen Birger. Han fick minst tio barn: oäktingen Gregers med en okänd kvinna, åtta barn varav två blivande kungar med Ingeborg och en dotter med Mechtild av Holstein. När kung Erik dog barnlös år 1250 såg Birger till sonen Valdemar, kungens systerson, övertog tronen enbart tolv år gammal. Det brukar antas att Birger var den som i praktiken styrde landet ända fram till sin död år 1266, men en professor i numismatik, myntforskning, har på goda grunder ifrågasatt detta. Valdemar gifte sig år 1260 med den danska prinsessan Sofia. Hon fann sig antagligen inte i att maken bara var kung till namnet. Birger förvisades att bli lokal potentat i västra Sverige från år 1261, där han kontrollerade myntningen och lät prägla silvermynt med bokstaven B som i Birger.</p>



<p class="wp-block-paragraph">   Samma år gifte sig Birger med Metchild, som var änka efter den man som mördat Sofias far kung Abel. Det har knappast roat Sofia. Man anar lätt norénska relationer i kungafamiljen. Birgers barn, barnbarn, barnbarnsbarn och barnbarnsbarnbarn skulle dessutom ägna det kommande seklet åt inbördes strider, fadersuppror och brodermord. Men nu kommer vi till Birgers bragd. Han lyckades skapa grunden för att hans stökiga släkt behöll tronen oavbrutet och därmed ett första medeltidsmodernt toppstyrt kungarike.</p>



<p class="wp-block-paragraph"><strong><mark class="has-inline-color has-luminous-vivid-orange-color">BIRGER JARLS HANDLINGAR </mark></strong>andas brutal och hänsynslös realpolitik. En liten historia antyder att han dessutom kan ha besuttit viss diplomatisk finess. När han påsken år 1257 ordnade stormöte med norrmännen förbjöd han sina män att kalla dem för ”baggar”, vilket betyder fårtestikel och var ett öknamn på norrmän, att jämföra med nutidens norrbaggar.</p>


<div class="wp-block-image">
<figure class="alignright size-large is-resized"><img src="https://elbilen.se/wp-content/uploads/sites/3/2023/02/Bild-3_-e1682512575903-725x1024.jpg" alt="" class="wp-image-3299" width="371" height="524" /><figcaption class="wp-element-caption">Ärr i brynet, grop i hakan. Foto: OSCAR NILSSON</figcaption></figure>
</div>


<p class="wp-block-paragraph"><strong><mark class="has-inline-color has-luminous-vivid-orange-color">OCH HUR SÅG</mark></strong> nu denne hårdföre flerbarnsfar ut? Birger jarl begravdes i Varnhems klosterkyrka i Västergötland. Att det blev just här är ingen slump. Klostret brann år 1234, och vid återuppbyggandet på 1250-talet var Birger en av huvudfinansiärerna. Som donator blev Birger avbildad i kyrkan. Högt uppe i kyrkans valv finns ett skulpterat ansikte i sandsten som bär en jarlskrona med Birger jarls personliga emblem, den fembladiga rosen. Porträttet kallas stiftarbilden.</p>



<p class="wp-block-paragraph">   – En av de verkligt intressanta frågorna i detta projekt blev naturligtvis att se i vilken mån stenansiktet gav en rättvis bild av Birger jarls ansikte, säger Oscar. Avbildningen visar ett slätrakat ansikte med en markerad och något kluven haka, en markerad mun med tydliga veck från näsan till mungipa. Det vågiga håret är format till rullar kring pannan som pryds med en jarlskrona. Det ser onekligen ut som en person med makt.</p>



<figure class="wp-block-image size-full"><img src="https://elbilen.se/wp-content/uploads/sites/3/2023/02/bilder-jarl-test.jpg" alt="" class="wp-image-209" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Birger jarls ansikte växer stegvis fram. FOTO: Oscar Nilsson</mark></strong></figcaption></figure>



<p class="wp-block-paragraph"><strong><mark class="has-inline-color has-luminous-vivid-orange-color">BIRGER JARLS SKELETT</mark></strong>, som återfanns i Varnhemsgraven på 1920-talet, har undersökts ett par gånger, senast av osteologen Maria Wretenmark.</p>



<p class="wp-block-paragraph">   – Jag fick själv vara med vid den sista gravöppningen, berättar Oscar. Skelettet visar att Birger bör ha varit runt 175 centimeter lång, alltså ganska lång för sin tid. Dödsåldern var ungefär 50–55 år, han hade välbehållna tänder och var robust byggd med markerade muskelfästen. Han var högerhänt, och man kunde också notera att han bör ha tillbringat mycket tid i hästsadeln. Och så hade han en läkt skada över höger ögonbryn.</p>



<blockquote class="wp-block-quote is-layout-flow wp-block-quote-is-layout-flow">
<p class="has-text-align-left wp-block-paragraph" style="font-size:30px"><strong><mark class="has-inline-color has-luminous-vivid-orange-color">Jag fick själv vara med vid den sista gravöppningen.</mark></strong></p>
</blockquote>



<p class="wp-block-paragraph">   – När jag under sommaren 2009 förberedde för att rekonstruera Birgers ansikte, fortsätter Oscar, behövdes i vanlig ordning en kopia på originalskallen. Och en sådan fanns faktiskt redan. Vid gravöppningen på 1920-talet gjorde man formar av lim på originalskallen, och göt sedan i gips. Ett otroligt vanskligt förfarande med gamla fragila skelett. Men skickligt utfört; kopian på kraniet som jag fick se hade mycket fin detaljåtergivning. Men nu dök det upp ett problem av det större slaget. Var fanns underkäken?</p>



<p class="wp-block-paragraph"><strong><mark class="has-inline-color has-luminous-vivid-orange-color">MÄRKLIGT NOG ÅTERFANNS</mark></strong> enbart kraniet, utan underkäke, i magasinet hos Historiska Museet i Lund. Det började luta åt att Oscar skulle få återskapa underkäken själv. Naturligtvis med stor hjälp av alla mått och bilder som fanns från de båda gravöppningarna, men ändå något som skulle sänka träffsäkerheten i rekonstruktionen en hel del. Under hösten 2009, i ett helt annat projekt, pratade Oscar med osteologen Leena Drenzel på Historiska Museet i Stockholm.</p>



<p class="wp-block-paragraph">   – Av en ren slump råkade jag nämna mysteriet om Birgers saknade underkäke för henne, säger Oscar, och hur frustrerande det kan vara ibland med gamla dammiga magasin på museer. Då tystnade Leena tvärt och jag undrade nästan om jag sagt något olämpligt. Men efter denna tankepaus sa hon att hon var säker på att hon sett skallen, med underkäken, registrerat i stockholmsmuseets magasin! Och mycket riktigt: det fanns verkligen en gipskopia av Birgers kranium och underkäke där! Ett halleluja-moment onekligen. Det visade sig att det gjordes två gjutningar i samma limform på 1920-talet, varav vi nu i alla fall hade hittat en komplett sådan. Mitt arbete kunde börja!</p>



<p class="wp-block-paragraph"><strong><mark class="has-inline-color has-luminous-vivid-orange-color">I DEN UTFÖRLIGA</mark></strong> osteologiska analys som gjordes av c m Fürst på 1920-talet skriver han att kraniet visar på ”ett ej högt och ganska brett ansikte med hög hjässa. Då underkäksvinkeln är stor, får ansiktet ett allmänt uttryck av kraft, som förhöjes i hög grad genom det betydliga ögonbrynspartiet och den höga hjässan. Hakan är markerad av utpräglade tubercula mentalia (=hakknölar). Han noterar även att ”näsan är smal, ej stor”.  I tillägg till detta kunde Oscar själv notera att kraniets canine fossa (beläget på främre delen av kinden, vid sidan av näsan) var tämligen djup. Detta betyder att han haft ett markerat nasolabialt veck, alltså rynkan som löper från näsvingen ner till mungipan. Vidare hade kraniet en väl läkt skada ovanför höger ögonbryn. Markerat och kraftigt vårtutskott bakom hörselgången pekade på både kraftig halsmuskulatur och öron som bör ha varit något större än genomsnittet.</p>



<p class="wp-block-paragraph">   – Vi vet inte vilka färger Birger hade på hår, hud och ögon, berättar Oscar. Så det fick bli en gissning från Medeltidsmuseets sida.</p>



<p class="wp-block-paragraph">   – Stiftarbilden i Varnhem visar att Birger hade en lång pagefrisyr där avslutningen verkar vara upprullad, med en klippt lugg uppdelad i sju stycken snurror, säger Oscar. Jag insåg omgående att det skulle bli omöjligt att överföra denna intrikata frisyr till min realistiskt utformade rekonstruktion. Men det hela blir lättare om man väljer att uppfatta stenansiktets frisyr som en stilisering av lockigt eller vågigt hår. Så fick det bli.</p>



<blockquote class="wp-block-quote is-layout-flow wp-block-quote-is-layout-flow">
<p class="wp-block-paragraph" style="font-size:30px"><strong><mark class="has-inline-color has-luminous-vivid-orange-color">Jag ser honom som maktlysten och brutal, säkert intelligent och högst troligt misstänksam mot sin omgivning.</mark></strong></p>
</blockquote>



<p class="wp-block-paragraph"><strong><mark class="has-inline-color has-luminous-vivid-orange-color">OSCAR NILSSON HAR</mark></strong> genom åren många gånger ombetts kommentera hur pass lik hans rekonstruktion är stiftarbilden. Även om stenansiktet är en stilisering, säkert också ganska tidstypisk i sin genre, så tycker han att det finns klara likheter. Det gäller hakan, som är markerad och kluven, ansiktsformen och även överläppen som skjuter ut från ansiktet och tydligt markerade nasolabiala veck.</p>


<div class="wp-block-image">
<figure class="alignright size-large is-resized"><img src="https://elbilen.se/wp-content/uploads/sites/3/2023/02/Bild-5_-768x1024.jpg" alt="" class="wp-image-3300" width="380" height="507" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Maktgalen, samvetsplågad eller vek – Birger jarls uttryck i Oscar Nilssons rekonstruktion kan uppfattas på flera olika sätt. FOTO: Oscar Nilsson</mark></strong></figcaption></figure>
</div>


<p class="wp-block-paragraph"><strong><mark class="has-inline-color has-luminous-vivid-orange-color">NÄR MAN NU</mark></strong> vet så mycket om Birger ville Oscar att något av detta skulle avspeglas i hans ansikte.</p>



<p class="wp-block-paragraph">   – Jag ser honom som maktlysten och brutal, säkert intelligent och högst troligt misstänksam mot sin omgivning. Vi ser alla olika saker i ett ansikte, i synnerhet gäller detta uttryck. Jag har hört väldigt olika beskrivningar på hur folk uppfattar Birgers uttryck i min rekonstruktion. Från att han ”ser helt maktgalen och brutal ut” och ”liknar Mussolini”, till att han ”ser samvetsplågad ut” och att han ”ser alldeles för feminin och vek ut”.</p>



<p class="wp-block-paragraph"><strong><mark class="has-inline-color has-luminous-vivid-orange-color">OSCAR VILL ÄNDÅ</mark></strong> alltid vara så minimalistisk och försiktig som han bara kan vad gäller uttryck. Ansiktets struktur och form måste alltid komma i första rummet. Det får inte skymmas av ett kraftigt uttryck, bara så mycket att man känner att det ”finns någon hemma”.                                                                  </p>



<p class="wp-block-paragraph">   – Och att det blir så spretande uppfattningar om uttrycket, som i Birgers fall, ser jag som ett plus, avslutar Oscar. Vi läser alla ansikten utifrån våra egna individuella föreställningar och vitt skilda erfarenheter. Särskilt glad blir jag när folk säger att de ser olika saker från olika vinklar. Då känns det som jag har lyckats och att det uppstått ett tredimensionellt porträtt, på riktigt, som lätt kalejdoskopiskt ändrar uttryck när man rör sig runt det.</p>
