Storkboet som dolde en skatt


<p class="has-medium-font-size"><strong>Ett av de största fynden inom den klassiska arkeologin på senare tid gjordes för ett tiotal år sedan – under ett storkbo.</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/02/Bild-1-test-768x1024.png" alt="" class="wp-image-243" width="434" height="579" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Uzunyuva-kolonnen fotograferad 2009. Ingen visste ännu vad som doldes bakom de massiva murarna…eller? Foto: Ragnar Hedlund</mark></strong></figcaption></figure></div>


<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">DEN LILLA STADEN</mark></strong> Milas, antikens Mylasa, i sydvästra Turkiet ger i&nbsp;dag ett något sömnigt intryck. Staden ligger i en dalgång, mitt i en bördig jordbruksbygd där bönderna odlar oliver och enorma vattenmeloner. På sommaren är hettan förlamande, lastbilar dundrar förbi på de dammiga vägarna. Staden har dock en lång historia. Och i över 2&nbsp;000 år har Milas ruvat på en hemlighet, som alltså uppdagats först nyligen.</p>



<p>   Mylasas historia kan spåras tillbaka till 600-talet f.Kr. Herodotos anger att det i staden fanns en urgammal helgedom tillägnad Zeus karios (”den kariske Zeus”). Staden lydde under perserna men var en av de många städer som deltog i det joniska upproret i början av 400-talet. Sedermera blev Mylasa också medlem i det attisk-deliska sjöförbundet, men perserna återtog området mot slutet av 400-talet. Under 300-talet regerade persiska satraper, innan Alexander erövrade området framåt slutet av århundradet.</p>



<blockquote class="wp-block-quote is-layout-flow wp-block-quote-is-layout-flow">
<p class="has-large-font-size"><strong><mark class="has-inline-color has-luminous-vivid-orange-color">Under lång tid var uzun yuva, som det kallas på turkiska (”högt bo”) ett bekant land­märke, i ett nedgånget kvarter i den äldsta delen av staden.</mark></strong></p>
</blockquote>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">MEN DET ÄR</mark></strong> förstås med storkboet vi borde börja. Under lång tid var uzun yuva, som det kallas på turkiska (”högt bo”) ett bekant landmärke, i ett nedgånget kvarter i den äldsta delen av staden. Här är antiken närvarande överallt; i den gamla moskén, högst upp på den antika stadens akropol, och i den intilliggande karavanseraljen är murarna fulla med spolier (återanvända byggstenar) från monumentala antika byggnader. Storkboet var anlagt på toppen av en antik korintisk kolonn i marmor. På kolonnen fanns tidigare en grekisk inskrift som förklarade att den var en hyllning till Menandros, sonson till Euthydemos. Euthydemos var en berömd talare från Mylasa som enligt vad man vet dog i mitten av första århundradet f.Kr. Kolonnen antas ha ställts upp mot slutet av första århundradet e.Kr. Inskriften är känd åtminstone sedan Jacob Spon, en av den klassiska arkeologins föregångare, reste genom området 1675–76 och då lade märke till den. Under 1700-talet och tidigt 1800-tal omnämns kolonnen av flera resenärer; till exempel såg London Society of Dilettanti till att dokumentera den ordentligt på 1760-talet. 1838 rapporterar dock arkeologen Charles Fellows att inskriften huggits bort av tomtägaren. Tydligen hade denne ledsnat på alla utlänningar som kom och frågade efter det märkvärdiga landmärket.</p>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">KOLONNEN STÅR I</mark></strong> sin tur på en mäktig mur, och andra massiva terrassmurar har alltid varit synliga precis nedanför. Det har alltså länge varit uppenbart att det borde finnas en stor anläggning gömd här. Men av vilket slag? Kanske det där templet helgat till Zeus karios som Herodotos omnämner och som alltså borde finnas någonstans i staden? Arkeologen Frank Rumscheid kom, efter noggranna undersökningar av området på 1990-talet, med ett annat förslag: att det rörde sig om ett mausoleum. Närmare bestämt en föregångare till det välkända mausoleet i det närbelägna Halikarnassos (dagens Bodrum) – som bekant ett av antikens sju underverk, uppfört som gravmonument åt Mausollos, den persiske satrapen som regerade i Halikarnassos.</p>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">ÅR 2010 GJORDES</mark></strong> så en oväntad upptäckt: bara något tiotal meter från stork-kolonnen uppdagades en illegal utgrävning, som antagligen pågått under flera år. Rovgrävarna hade borrat sig in i en gravkammare som visade sig tillhöra en monumental grav. I graven fanns väggmålningar och en enorm sarkofag med reliefer på alla sidor. Intrånget hade ställt till stor förödelse, det värsta var att vatten hade fyllt gravkammaren genom rovgrävarnas borrhål och framför allt skadat väggrelieferna svårt. Sarkofagen hade dock, som tur var, klarat sig någorlunda bra.</p>



<p>   Nu började utgrävningarna och flera hus på tomten revs helt sonika ned. Fyndet var häpnadsväckande. Gravkammaren visade sig ligger dold under en enorm och massiv rektangulär stenplattform som mäter 42&#215;36 meter. Dimensionerna och formen påminde mycket riktigt om mausoleet i Halikarnassos. Nu hade man alltså hittat ett TILL mausoleum av samma typ, därtill avsevärt mer välbevarat! Men vem var då detta byggt för?</p>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">REDAN FRÅN BÖRJAN</mark></strong> var det uppenbart att vi även här har att göra med ett gravmonument tillhörande Mausollos familj, de så kallade hekatomniderna, med namn efter stamfadern Hekatomnos. Vissa detaljer i exteriörens arkitektur är stilistiskt mycket lika det man funnit i Halikarnassos, så lika att det till och med skulle kunna vara samma hantverkare som varit verksamma här. Går vi sen in i gravkammaren så syns på relieferna runt sarkofagen en rad majestätiska gestalter och bland dem känner vi igen Mausollos anlete. Det är ju väl bekant från den berömda skulptur som påträffades intill mausoleet i Halikarnassos och som i&nbsp;dag kan ses på British Museum. Men vem i hans familj blev då begravd här i Milas?</p>



<figure class="wp-block-image size-full"><img src="https://elbilen.se/wp-content/uploads/sites/3/2023/02/Bild-2..jpeg" alt="" class="wp-image-244" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Bara några år senare såg området (här fotograferat ovanifrån) radikalt annorlunda ut. Grundmurarna till plattformen har frilags på alla sidor och ett tak har byggts över nedgången till själva gravkammaren. Bortanför taket sticker uzunyuva-kolonnen upp. Foto: Ragnar Hedlund 2020</mark></strong></figcaption></figure>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">HÄR BEHÖVER VI</mark></strong> göra en mindre exkurs. Hekatomnos var satrap (392/1–377 f.Kr.) under den persiske storkonungen Artaxerxes II och Mylasa var hans huvudstad. Han gifte sig med sin syster Aba, vilket var praxis. De fick fem barn: Mausollos, Artemisia, Idrieus, Ada och Pixodaros. Mausollos efterträdde Hekatomnos och flyttade huvudstaden till Halikarnassos, där han regerade tillsammans med Artemisia och alltså begravdes efter sin död 353/2 f.Kr. Spåren efter Mausollos är dock få, eftersom mausoleet i princip är helt försvunnet (även om det delvis stod kvar fram till korstågen). Betydligt fler spår finns det i helgedomen Labraunda, helgad till Zeus Labraundos, som ligger i bergen ovanför Mylasa. Här lät Mausollos bygga en rad monumentala byggnader, som grävts ut av svenska arkeologer sedan 1948 och nu undersöks av ett internationellt team.</p>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">ARTEMISIA GICK BORT</mark></strong> bara två år efter Mausollos. Då tog Mausollos broder Idrieus över makten tillsammans med systern Ada, men Idrieus dog redan 344/3 och Ada några år senare. Brodern Pixodaros hann också regera i fem år och hans dotter Ada i ytterligare två år, innan Alexander den store tog över Karien år 334 f.Kr. Därefter försvinner hekatomniderna ur historien.</p>



<p>   Det borde alltså vara någon av dessa familjemedlemmar – Hekatomnos, Idrieus, Ada eller Pixodaros – som lades till vila i gravmonumentet i Mylasa. Arkeologerna som undersökt det nya mausoleet i Mylasa är säkra på sin sak: detta är stamfadern Hekatomnos grav, Hekatomneion. På en av relieferna på sarkofagen syns bland annat en äldre man som ligger till bords, medan en annan relief visar en sörjande Mausollos: det måste förstås vara den döde fadern som ligger till bords och som sörjs av sonen. Några riktigt säkra belägg för denna identifikation tycks inte finnas, men hekatomneion låter förstås bra, som en sevärdhet väl i klass med Bodrums mer berömda mausoleion.</p>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">VISSA DETALJER PÅ</mark></strong> det bevarade monumentet pekar dock i en annan riktning. Det är nämligen uppenbart att monumentet aldrig blev klart – flera av de massiva stenblocken i de övre murskiften har inte blivit färdighuggna. Och om monumentet blev klart, varför har vi då inte känt till det förrän nu? Borde det inte finnas mer bevarat?</p>



<p>   En alternativ förklaring skulle kunna vara att graven byggdes åt Idrieus, vilket i flera avseenden skulle passa bättre än Hekatomnos. Det är uppenbart att Idrieus inte ville vara sämre än brodern; han byggde också en andron (matsal i anslutning till ett tempel) i Labraunda som var ännu större än broderns.</p>



<p>   Vi vet också att han, liksom fadern, valde att regera från Mylasa. Det ligger nära till hands att även Idreus önskade få ett lika monumentalt gravmonument som Mausollos.</p>



<p>   Det faktum att han dog oväntat skulle kunna förklara varför bygget avbröts och aldrig färdigställdes. Att platsen senare övergavs är tydligt även från de arkeologiska fynden.</p>



<p>   Utöver mausoleets grundmurar finns grunden till ett lika monumentalt altare (som kanske inte heller blev klart), och någon gång under senantiken byggdes det i sin tur över av en väg med kolonnader på båda sidor.</p>



<figure class="wp-block-image size-full"><img src="https://elbilen.se/wp-content/uploads/sites/3/2023/02/Bild-3.-Storkboet.-ingangen-till-graven.-hellotravel.com_.jpg" alt="" class="wp-image-245" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Ingångskorridoren till graven. Foto: <a href="http://hellotravel.com">hellotravel.com</a></mark></strong></figcaption></figure>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">VILKEN AV HEKATOMNIDERNA</mark></strong> som än begravdes här – om bygget någonsin blev klart vill säga – så visar det tydligt på familjens ambitioner att anamma kulturella intryck från flera håll. Deras monumentala byggnader i Labraunda som svenska arkeologer kunnat rekonstruera är byggda i en mycket egen stil som kombinerar joniska och doriska element. I Uzunyuva-monumentets gravkammare finns fresker som avbildar stridsscener mot amazoner och kentaurer, precis som på till exempel Parthenon i Athen, och jaktscener som är mycket vanliga motiv överallt i den antika världen. Det är alltså ytterligare ett bevis på den kulturella smältdegel som hekatomnidernas rike utgjorde.</p>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">NÅGON TYCKS I</mark></strong> vilket fall ha begravts här, att döma av fynden från gravkammaren och gången utanför den. Denna någon bör ha varit en förnäm person; i den förödelse som rovgrävarna lämnade efter sig hittades fragment av guldföremål, däremot inget skelettmaterial. Sannolikt plundrades graven redan under antiken.</p>



<p>   Utredarna kunde senare knyta ett antal föremål som hittades vid ett annat museum, bland annat dekorationer från sarkofagen och guldsmycken, till den monumentala graven.</p>



<p>   En hellenistisk guldkrona som togs i beslag i Edinburgh anses också härröra härifrån. De fortsatta utgrävningarna tyder vidare på att graven troligtvis återanvänts åtminstone vid något senare tillfälle, troligtvis under romersk tid.</p>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">FLERA FRÅGOR ÄR</mark></strong> ännu obesvarade. Uzunyuva-monumentet är i&nbsp;dag ett museiområde. Av bevarandeskäl är inte gravkammaren tillgänglig, men det finns ett litet museum i anslutning med avbildningar av både freskerna och sarkofagrelieferna. Där finns också ett litet kafé och ett museum ägnat åt ortens berömda matt-tradition.</p>



<p>   Planer finns på att bygga ett nytt arkeologiskt museum, men de planerna verkar för stunden ha gått i stå. Gamla stan håller under tiden på att leva upp igen. Flera av de gamla husen har renoverats, och butiker och restauranger har öppnats. I närheten finns till exempel den populära meze-restaurangen Paparaki, där man under sommarhelger har en god chans att stöta på åtminstone delar av Labraundateamet.</p>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">OCH STORKARNA BOR</mark></strong> fortfarande kvar högst upp på sin kolonn, som om inget hänt. Kanske undrar de vad i all sin dar de där besynnerliga människorna har ställt till sånt fasligt liv om därnere.</p>


