Det franska runmysteriet – satte svenska munkar sten i Orléans?


<p class="has-medium-font-size wp-block-paragraph"><strong>Den nordamerikanska Kensingtonstenens gåta får idag betraktas som löst. Det handlar om ett falsarium från förra sekelskiftet. Men nu kan Populär Arkeologi äntligen berätta om ett minst lika stort men närmast okänt franskt runmysterium. En gång i tiden fängslades Sveriges främsta runexperter av det märkliga fyndet. <em>Runologen Magnus Källström </em>lotsar oss runt på en dyster kyrkogård i Orléans, sörmländska munkar hastar förbi bakom grav­stenarna och, ja, svenska kungahuset kan vara inblandat!</strong></p>



<figure class="wp-block-image size-full"><img src="https://elbilen.se/wp-content/uploads/sites/3/2021/03/Jollois-Antiquites-s.-69-1.jpg" alt="" class="wp-image-1194" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Stämningsbild från den övergivna kyrkogården i Orléans. Efter Jean Baptiste Prosper Jollois, Antiquités Du Grand Cimetière d’Orléans (1831). Foto: Google books</mark></strong></figcaption></figure>


<div class="wp-block-image">
<figure class="alignright size-large is-resized"><img src="https://elbilen.se/wp-content/uploads/sites/3/2021/03/M„rkligt-svenskt-fornminne-Orl‚ans-407x1024.jpg" alt="" class="wp-image-1195" width="326" height="820" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Frits Läffler var först med nyheten i pressen. Foto: KB</mark></strong></figcaption></figure>
</div>


<p class="wp-block-paragraph"><strong><mark class="has-inline-color has-luminous-vivid-orange-color">DENNA HISTORIA BÖRJA</mark></strong> kan man säga med ett brev, som i augusti 1901 ankom till Nordiska museet i Stockholm. Brevskrivaren var en monsieur Léon Dumuys, vice president i La Socité archéologique i Orléans. Syftet med brevet var tvåfaldigt, dels att beklaga Arthur Hazelius bortgång i maj samma år – Dumuys berättar att han lärt känna honom vid ett besök i Stockholm 1888 – dels att meddela en märklig upptäckt som han hade gjort i Orléans. I anteckningar efter en lokal forskare, en monsieur Vergnaud-Romagnési, hade man funnit uppteckningar av en gravhäll från 1300-talet med en inskrift med runor!</p>



<p class="wp-block-paragraph"><strong><mark class="has-inline-color has-luminous-vivid-orange-color">DUMUYS BREV VÄCKTE</mark></strong> genast uppmärksamhet i Stockholm och togs om hand av de runkunniga i staden. En dryg månad senare, söndagen den 15 september, publicerade professor Frits Läffler en artikel i Stockholms Dagblad med titeln »Märkligt svenskt fornminne i Frankrike. Runinskrift från 1300-talet öfver en borgare af svensk härkomst, begrafven i staden Orléans». Han redogjorde här för inskriften, som var på latin och som han tolkade på följande sätt (i huvudsak i anslutning till den tolkning som Vergnaud-Romagnési redan hade gett):</p>



<p class="has-text-align-left wp-block-paragraph">»Här ligger begrafven Johan Christiansson, född i Södermanland, borgare i Orléans ….. donator; åt klostret Bonneval gaf han ett hus midt emot (kyrkan) Sancta Cathrina, åt kyrkogården penningar. Död år 1334 (1344?). Här lade Södermanländske bröder och studenter vid universitetet i Orléans minnesvården.»</p>



<p class="wp-block-paragraph">Upptäckten av denna inskrift föranledde litteraturhistorikern Henrik Schück att redan påföljande söndag publicera en utredning om svenska studenter i Orléans under rubriken »Ett blad ur vår medeltidshistoria». Någon Johan Christiansson eller Johannes Christianisati som det stod på hällen hade han inte kunnat uppspåra, men han gav exempel på en del andra svenskar som hade studerat i staden under medeltiden.</p>



<p class="wp-block-paragraph">   Den vetenskapliga behandlingen av den nyupptäckta runinskriften var inte slut i och med detta, utan arbetet fortsattes av runologen Erik Brate, som i Vitterhetsakademiens månadsblad samma år offentliggjorde en längre undersökning med titeln »Runstenen i Orléans».</p>



<p class="wp-block-paragraph">   Brate kom i stort sett fram till samma tolkning som Läffler, men modifierade några detaljer. I den lite förbryllande namnformen <em>Christanisati </em>där Läffler trott sig finna ett <em>satus </em>med betydelsen ’son’ (egentligen sådd) avskilde Brate sati och tolkade det som ett binamn med betydelsen ’förtrolig’ eller ’försonlig’. Årtalet ändrades också till 1364 eller 1384 och han gav följande översättning av hela texten:</p>



<p class="has-text-align-left wp-block-paragraph">»Joan Kristerson Sati, född i Södermanland, borgare i Orléans … skänkte … åt (sankt Florentinus’) kloster i Bonneval ett hus midt emot (sankt) Katarina (kyrka). Åt (stora) kyrkogården gaf han (en summa) penningar. Han afled år 1364. Här satte södermanländska munkar, studerande vid universitetet i Orléans (hans minnesvård).»</p>


<div class="wp-block-image">
<figure class="alignright size-large is-resized"><img src="https://elbilen.se/wp-content/uploads/sites/3/2023/03/Erik-Brate-739x1024.jpg" alt="" class="wp-image-1196" width="295" height="408" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Erik Brate, runologen som funderade på den franska runstenen. Foto: Runverkets bildsamling</mark></strong></figcaption></figure>
</div>


<p class="wp-block-paragraph"><strong><mark class="has-inline-color has-luminous-vivid-orange-color">REDAN VERGNAUD-ROMAGNÉSI</mark></strong> hade pekat på att det namn som han hade funnit i runinskriften också förekom i en annan historisk källa. I ett verk från 1778 av historieskrivaren Beauvais de Préau finns en notis om att en Jean Christanisati den 12 mars 1364 skulle ha skänkt ett hus kallat <em>la Maison du Cheval-­blanc</em> till klostret Bonneval. Uppgiften komplicerades dock av att en Charles Cuissard 1881 kunde visa att det fanns ett diplom från 1375, där det omtalas att en borgare vid namn Jean Lestrestienne hade skänkt ett hus kallat <em>Hôtel du Cheval-Blanc</em> till klostret. Detta måste vara samma person som Jean Christianisati, men eftersom Jean Lestrestienne ännu levde när diplomet utfärdades, kunde hans dödsår inte gärna vara 1364, utan måste efter en av läsarterna på gravstenen korrigeras till 1384.</p>



<p class="wp-block-paragraph">   Brates artikel översattes till franska och trycktes i en fransk tidskrift 1907. Inskriften och de historiska källorna behandlades också i en artikel 1929 av fransmannen Albert Sidoisne, men sedan dess har det varit ganska tyst. I runologisk litteratur nämns denna inskrift ytterst sällan och den är nog okänd för de allra flesta.</p>



<figure class="wp-block-image size-large"><img src="https://elbilen.se/wp-content/uploads/sites/3/2021/03/mixbild-890x1024.jpg" alt="" class="wp-image-1198" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Vergnaud-Romagnésis uppteckning av runorna på gravstenen i Orléans. Efter Erik Brate 1901.</mark></strong></figcaption></figure>



<p class="wp-block-paragraph"><strong><mark class="has-inline-color has-luminous-vivid-orange-color">MEN HAR DET </mark></strong>verkligen funnits en runsten från 1300-talet i Orléans? För att besvara denna fråga måste vi återvända till den tid då den först upptäcktes. Gravvården ska alltså ha haft sin plats på den stora kyrkogården i Orléans, vilken år 1786 stängdes för vidare begravningar och som 1824 uppläts till byggandet av en Halle aux blés – en spannmålsmarknad. Enligt Vergnaud-Romagnési låg stenen när han undersökte den i en pelargång som bar namnet Galerie du Saint-Esprit och som upptog kyrkogårdens östra sida.</p>



<p class="wp-block-paragraph">   Vergnaud-Romagnési kunde först inte läsa inskriften, men kopierade tecknen noggrant och fick efter att ha jämfört med runraden, det gotiska alfabetet och frakturstilen slutligen fram en text som dominerades av runor, men som också hade inslag av de två andra skriftsystemen. Hans tolkning var i stort sett den som Läffler senare refererade i Stockholms Dagblad.<br />Stenen har därefter försvunnit och Vergnaud-Romagnésis avbildning är den enda som existerar och som all senare forskning har byggt på. Men vad säger denna uppteckning egentligen en runolog? Det första som man noterar är det lite märkliga sätt på vilket de skadade partierna är fördelade. Nästan alla ord är inkompletta, men skadorna har av någon anledning nästan uteslutande drabbat slutet av orden. Trots detta har Vergnaud-Romagnési utan större problem kunnat rekonstruera de flesta. Något som också är påfallande är blandningen av olika skriftsystem. Visserligen förekommer under medeltiden att runor och latinska bokstäver ibland samsas i samma inskrift, men det är ytterst sällan som de på detta sätt växlar i ett och samma ord. Märkligast är dock att inskriften skulle ha innehållit tecken från det gotiska alfabetet. Detta blev ju först återupptäckt på 1500-talet genom den berömda silverbibeln och det är svårt att tro att svenska 1300-talsmunkar skulle ha känt till detta skriftsystem. Ett av de antaget gotiska tecknen – o – råkar dessutom ha nästan samma form som den urnordiska runan för <strong>o (ᛟ)</strong> som här uppträder vid sidan av den medeltida <strong>o</strong>-runan, men bara i namnet <em>Johan(nes) </em>och ortnamnet <em>Orléans</em>. På samma sätt förekommer också både den latinska bokstaven S och runan <strong>s</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/03/Brderna-Magnus-runalfabet-1024x652.jpg" alt="" class="wp-image-1199" width="351" height="223" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Bröderna Magnus runalfabet som trycktes i Rom 1554-55. Efter Otto von Friesen 1933.</mark></strong></figcaption></figure>
</div>


<p class="wp-block-paragraph"><strong><mark class="has-inline-color has-luminous-vivid-orange-color">ÄVEN BLAND DE</mark></strong> mer ordinära runorna finns en del som sticker ut. Runorna för <strong>o</strong>, <strong>n </strong>och <strong>a </strong>har ensidiga bistavar som var brukligt under medeltiden, medan däremot <strong>t</strong>-runan uppträder med dubbla bistavar. Denna form är inte okänd i medeltida runinskrifter, men det vanligaste var att runan bara hade en bistav åt vänster. På Gotland användes varianten med dubbla bistavar under hela medeltiden, men på fastlandet försvinner den tidigt och verkar inte förekomma efter 1200-talet. Det är då lite märkligt att finna den använd av sörmlänningar på en gravsten i Frankrike under den senare delen av 1300-talet. Ännu märkligare är att den stungna varianten av samma runa som ska ha funnits på stenen bara har en bistav!</p>



<p class="wp-block-paragraph">   Även en annan runform är värd att uppmärksamma, nämligen runan för <strong>c</strong>, som tre gånger har formen av en bakvänd <strong>k</strong>-runa och en gång som en rättvänd sådan. Denna c-runa är annars okänd, även om det förekommer att den rättvända <strong>k</strong>-runan används för latinets c. Anmärkningsvärd är också formen på <strong>e</strong>-runan som för det mesta har fått formen av ett kors.</p>



<p class="wp-block-paragraph">   Söker man efter paralleller till teckenuppsättningen på runstenen i Orléans så liknar den mest det runalfabet som de landsflyktiga katolska biskoparna Johannes och Olaus Magnus lät trycka i Rom 1554 och 1555. Vi känner här igen <strong>t</strong>-runan med dubbla bistavar, den korsformiga <strong>e</strong>-runan och kan dessutom notera att <strong>k</strong>-runan – fast rättvänd – anges som en variant för <strong>c</strong>. Bröderna Magnus verk fick en stor spridning under de följande århundradena och de flesta av de sentida runtraditioner som möter i Norden under nyare tid kan härledas från just detta tryckta runalfabet.</p>



<p class="wp-block-paragraph">   Även i stavningen finns det en del som förvånar, t.ex. att <em>Christianisa[ti]</em> stavas med <em>ch</em>. Detta är visserligen i linje med den latinska stavningen, men i nordiska runinskrifter verkar denna skrivning fullständigt främmande. Namnet <em>Christian</em> finns visserligen inte belagt i någon runinskrift, men <em>Christus</em> uppträder i olika former ett femtiotal gånger och skrivs antingen med inledande <strong>k </strong>eller med <strong>c</strong>, men aldrig med <strong>ch</strong>.</p>



<p class="wp-block-paragraph">   Det märkligaste är dock att både <strong>d </strong>och <strong>þ </strong>används som tecken för <em>d </em>och dessutom där den fonetiska omgivningen är helt identisk. Ordet <em>dedit</em> skrivs <strong>dedit</strong> med <strong>d</strong>, men defunctus som <strong>þefunc</strong>… med <strong>þ</strong>. Tecknen ha alltså varit fullständigt utbytbara för den som har skapat denna text, vilket passar mycket illa i ett medeltida sammanhang. Istället leder det tankarna till efterreformatoriska uppställningar av runor baserade på bröderna Magnus runalfabet, där både <strong>d </strong>och <strong>þ </strong>brukar anges som motsvarigheter till <em>d</em>.</p>


<div class="wp-block-image">
<figure class="alignleft size-large is-resized"><img src="https://elbilen.se/wp-content/uploads/sites/3/2021/03/Jollois-Antiquit‚s-s.-65-773x1024.jpg" alt="" class="wp-image-1201" width="366" height="484" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Vy från kyrkogården i Orléans. Runskriften sades finnas på en gravhäll i pelargången till höger. Efter Jean Baptiste Prosper Jollois, Antiquités Du Grand Cimetière d´Orléans (1831). Foto: Google books</mark></strong></figcaption></figure>
</div>


<p class="wp-block-paragraph"><strong><mark class="has-inline-color has-luminous-vivid-orange-color">DET FINNS ALLTSÅ</mark></strong> mycket som är anmärkningsvärt ur runologisk synvinkel i denna inskrift och man borde kanske titta lite närmare på den som har upptecknat inskriften, nämligen Charles François Vergnaud-Romagnési (1785–1870). Han har karakteriserats som ett outtröttlig forskare med ett brinnande intresse för arkeologi och historia rörande framför allt Orléans och dess omgivningar. Han satt i många lärda akademier och var dessutom verksam som kemist, jordbrukare och som uppfinnare. Trots detta är hans eftermäle som vetenskapsman kanske inte det bästa. Jacques Soyer, som skrev om honom 1925 i samband med ett par misstänkt förfalskade inskrifter i Germigny-des-Prés, karakteriserar honom som »en oförtröttlig komplilator utan kritiskt tänkande, en dålig författare, en ganska duktig samlare men något skrupulös, mycket intrigerande och mån om att bli uppmärksammad». Dessutom ska han enligt uppgift ha älskat att högljutt kungöra sina sensationella fynd och ständigt försökt att vilseleda sina kollegor i historia och arkeologi.</p>



<p class="wp-block-paragraph">   Ett exempel på det senare ger en monsieur Du Faur i en artikel från 1844. På ett skulpterat kapitäl i klosterkyrkan i klostret Saint-Benoît-sur-Loire finns en latinsk inskrift som lyder<em> Gladii de ore Domini exite – Johannes – Tremite </em>»Svärd kommer ur Guds mun, Johannes, bäva!» och som syftar på en passage i Uppenbarelseboken. Vergnaud-Romagnési har här i en av sina skrifter istället funnit en mycket skadad inskrift, där en Giadisophe hade besegrat (den annars okände) normanden Deorednus till Kristi ära. Slående med denna inskrift är att det framför allt är början av orden som Vergnaud-Romagnési har kunnat läsa, precis som på den runristade gravstenen i Orléans.</p>


<div class="wp-block-image is-style-rounded">
<figure class="alignleft size-large is-resized"><img src="https://elbilen.se/wp-content/uploads/sites/3/2023/03/Vergnaud-Romagn‚si-edited.jpg" alt="" class="wp-image-1203" width="361" height="361" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Charles-François Vergnaud-Romagnési,<br />år 1825. Foto: Pôle l´archéologie à Orléans</mark></strong></figcaption></figure>
</div>


<p class="wp-block-paragraph">   Detta är alltså den person som har dokumenterat runorna på den gamla kyrkogården och på vars vitsord forskningen hittills har vilat. Frågan är om vi vågar lita på honom i detta fall? Visserligen verkar ju gravhällens runinskrift på ett märkligt sätt bekräftas av andra källor och Vergnaud-Romagnési hänvisar själv till en passage hos historieskrivaren Beauvais de Préau från 1778. Den lyder:</p>



<p class="wp-block-paragraph">Undersöker man den korta texten lite närmare upptäcker man att det mesta av innehållet i gravinskriften finns redan här: en man vid namn Jean Christianisati, borgare i Orléans, har år 1364 skänkt ett hus beläget mitt emot kyrkan Sainte Catherine till klostret Bonneval. Vad som saknas är egentligen bara uppgiften att han skulle vara född i Södermanland och knuten till universitetet i Orléans.</p>



<figure class="wp-block-image size-full"><img src="https://elbilen.se/wp-content/uploads/sites/3/2023/03/Beauvais-de-Pr‚au-1778-scaled.jpg" alt="" class="wp-image-1204" /></figure>



<p class="wp-block-paragraph">   Det är ju ett egendomligt sammanträffande att just dessa uppgifter skulle finnas ristade med runor på den nämnda gravhällen. Samtidigt verkar det rätt osannolikt att inskriften skulle vara fritt uppfunnen, inte minst med tanke på hur pass okänt detta skriftsystem måste ha varit i Frankrike. Märkligt nog verkar just Vergnaud-Romagnési ha ägnat sig åt just runor i ett annat sammanhang ungefär vid samma tid.</p>



<p class="wp-block-paragraph">   År 1825, alltså ett år efter att han hade upptecknat runorna på gravstenen på den stora kyrkogården, höll han nämligen ett anförande vid<em> la Société Royale de Sciences, Belles-Lettre et Arts d’Orléans</em>, där han behandlade en träkalender med runor som han hade fått förmånen att undersöka. Anförandet kom så småningom i tryck, men inte förrän 1852, alltså nästan trettio år senare. Enligt Vergnaud-Romagnési hade den lilla bokformade träkalendern hamnat i Frankrike under högst märkliga omständigheter. Han hade fått låna den av en läkare, Nicolas Pellieux, som i sin tur hade fått den i gåva på ett sjukhus under Napoleonkrigen av en döende norsk soldat. Norrmannen skulle ha burit den lilla träkalendern i en läderrem under armen, men eftersom de inte kunde utväxla mer än några få ord på dåligt latin, fick inte doktor Pellieux några som helst upplysningar om den lilla träbokens innehåll.</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">Texten är av allt att döma fabricerad.</mark></strong></p>
</blockquote>


<div class="wp-block-image">
<figure class="alignleft size-full is-resized"><img src="https://elbilen.se/wp-content/uploads/sites/3/2023/03/Runalfabet-Vergnaud-Romagn‚si-omkastade-runor-p†-slutet.jpg" alt="" class="wp-image-1205" width="309" height="368" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Vergnaud-Romagnésis runalfabet från 1852 med de felaktiga runorna på slutet korrigerade. <br />Foto: Magnus Källström</mark></strong></figcaption></figure>
</div>


<p class="wp-block-paragraph">   Vergnaud-Romagnési trodde att kalendern var medeltida, men det namn som fanns inskuret i högrelief på framsidan avslöjar vem som hade ägt den. Där stod OLAUS VERELIUS, vilket ju klingar välbekant i svenska öron. Olof Verelius var professor vid universitetet i Uppsala under den senare delen av 1600-talet och gav bland annat ut en mycket inflytelserik handbok i runologi. Kalendern har alltså tillhört honom och har nog knappast hamnat i Frankrike på det sätt Vergnaud-Romagnési beskriver.</p>



<p class="wp-block-paragraph"><strong><mark class="has-inline-color has-luminous-vivid-orange-color">DET INTRESSANTASTE MED </mark></strong>den lilla publikationen från 1852 är att det där även återges ett runalfabet i ABC-ordning. Detta är tydligt baserat på bröderna Magnus ovan nämnda tryckta runalfabet från mitten av 1500-talet. Här står <strong>d </strong>och <strong>þ </strong>tillsammans under bokstaven D, <strong>e</strong>-runan har närmast formen av ett kors och en <strong>k</strong>-runa (men en rättvänd sådan) är placerad under C. Slutet av runalfabetet ser däremot mycket konstigt ut och det är tydligt att de tio sista runorna står upp och ned och att de därför har associerats med fel bokstäver. Vänder man dem rätt så gör man en märklig upptäckt. Bland de i övrigt i huvudsak medeltida runformerna hamnar under bokstaven <strong>Œ </strong>en runa som ser ut som den urnordiska o-runan! Eftersom den urnordiska runraden dechiffrerades så sent som 1839 bör dock källan här snarast ha varit den anglosaxiska runraden, där ᛟ har just ljudvärdet œ. Samtidigt är det ett mycket märkligt sammanträffande att här precis som på gravstenen i Orléans finna detta tecken bland i övrigt medeltida runor.</p>



<p class="wp-block-paragraph">  Textinnehållet och runtecknen har alltså Vergnaud-Romagnési kunnat hämta från olika källor. Att Jean har döpts om till Johannes är väl inte så konstigt, men varför skulle han vara svensk och född i just Södermanland? Åtminstone det senare borde väl inte vara så lätt att bara gripa ur luften?</p>


<div class="wp-block-image">
<figure class="alignleft size-large is-resized"><img src="https://elbilen.se/wp-content/uploads/sites/3/2021/03/ATTACHMENT-0001-858x1024.jpg" alt="" class="wp-image-1206" width="322" height="384" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Oscar – Sveriges och Norges kronprins och tillika hertig av Södermanland – omkring år 1825. Litografi av Samuel Herman von Stahl efter oljemålning av Fredrik Westin. Foto: Alvin/UUB</mark></strong></figcaption></figure>
</div>


<p class="wp-block-paragraph">   Här kan det vara på sin plats att erinra om att en av Napoleons generaler och sedermera marskalk, Jean Baptiste Bernadotte, år 1810 blev kronprins av Sverige och adopterades av kung Karl XIII. År 1818 dog kungen och Jean Baptiste tog då namnet Karl Johan. Detta gav givetvis visst eko i fransk press. I en liten notis i den lokala <em>Journal de Loiret</em> den 28 februari 1818 kan man exempelvis läsa att den svenske kungen Charles XIII har avlidit, men att det är osäkert om den då 53-årige kronprinsen ska ta kunganamnet <em>Charles XIV</em> eller<em> Jean IV</em>. Avslutningsvis nämns att den nya kronprinsen Oscar är 19 år, men också att han är <em>duc de Sudermanie </em>»hertig av Södermanland»! Genom Jean Baptist som blev Karl Johan och hans son var hertig av Södermanland, kunde alltså Vergnaud-Romagnési från en artikel som denna få idén att göra Jean Christianisati till svensk! Det är inte omöjligt att det svenska landskapsnamnet har återkommit i fransk press när Oscar gifte sig med Joséphine av Leuchtenberg, dotter till en annan av Napoleons generaler. Detta skedde den 19 juni 1823, vilket faktiskt bara är ett år innan Vergnaud-Romagnési författar sin skrift om den gamla kyrkogården i Orléans och där finner en sten med skandinaviska runor!</p>



<p class="wp-block-paragraph"><strong><mark class="has-inline-color has-luminous-vivid-orange-color">ATT SJÄLVA GRAVSTENEN</mark></strong> har existerat ska vi nog däremot räkna med. Som Vergnaud-Romagnési framhåller verkar den nämligen finnas omtalad bland de uppteckningar av gravinskrifterna på kyrkogården som sammanställdes redan år 1787 av en P. Blondel. Denne har dock inte upptecknat något av själva inskriften, men uppger att det på stenen fanns ett kors och några skulpterade ornament samt därunder sex rader med text. Det som återstod var de sista orden i varje rad och det var därför enligt Blondel omöjligt att få något sammanhang i texten. Detta stämmer ju inte alls med Vergnaud-Romagnésis återgivning, där det istället är <em>början </em>av orden som har bevarats samtidigt som dessa textfragment är jämnt utspridda i raderna. Blondel säger inte heller något om att inskriften skulle ha utgjorts av något särskilt skriftsystem.</p>



<p class="wp-block-paragraph">   Det mesta tyder alltså på att det aldrig har funnits någon runristad gravsten lagd över den sörmländske Johan Christiansson i Orléans. Texten är av allt att döma fabricerad av den som säger sig ha upptäckt den. Frankrike har därmed dessvärre berövats ett av sina få runminnen.</p>
