Kvartals nyhetsbrev

Tack!

Välkommen som prenumerant på Kvartals nyhetsbrev.

Skip to content
Kultur |

Schulman och sanningen

Det viktiga är att det känns sant, tycker Alex Schulman. Foto: Malin Hoelstad / TT.

I den hyllade romanen Bränn alla mina brev demoniserar Alex Schulman sin egen morfar kulturkritikern Sven Stolpe – som han anklagar för ett mordförsök motiverat av vad som ska bli ett livslångt hat mot rivalen Olof Lagercrantz. Men spelar det någon roll om en författare förtalar en död släkting? Ja, rimligtvis om han samtidigt använder medierna för att påstå att boken berättar sanningen – och hänvisar till sin omfattande research i arkivmaterial. För när Lapo Lappin går till källorna visar sig berättelsens bärande delar vara ett fuskbygge.

Lyssna på texten
Laddar ...
Följ Kvartals poddar: Apple | Spotify
Av Lapo Lappin | 31 mars 2023
Lapo Lappin är kulturskribent med bakgrund inom filosofin och medarbetare i Kvartals redaktion.
Lästid 41 min
I korthet

”Jag slarvar och skarvar, jag adderar och drar ifrån, därför att livet är en berättelse. Det viktigaste är att det känns sant.” Så säger den framgångsrike författaren och poddaren Alex Schulman i en intervju i P1.1 Det citatet hade kunnat sammanfatta Schulmans inställning till sanningen, men så enkelt är det inte. Det finns också en annan Schulman. Han som insisterar på att det han skriver är sant och hänvisar till omfattande research. Den Schulman som hävdar att han är ”väldigt noga med att det ska vara sant”, som ”vinnlagt sig om att det ska vara dokumentärt”.2 Det är när han pratar om romanen Bränn alla mina brev (2018) som handlar om Schulmans mormors otrohetsaffär med den kände publicisten Olof Lagercrantz.

<div class="kv-article-audio-player">  <div class="kv-aap-listen">    <div class="kv-listen-left">      <span>        <i class="fas fa-headphones-alt"></i>      </span>    </div>    <div class="kv-aap-listen-right">      Lyssna på texten    </div>  </div><div id    = "kv-pod-holder-91667"      class = "kv-pod-holder kv-player-light  lplo " data-sid="" data-eid="" data-pid="91667" data-acurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2Uva3ZhcnRhbC9pbmxhc3Rfc2NodWxtYW5fb2NoX3Nhbm5pbmdlbi5tcDM=" data-psurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2Uva2p4ajYzeWRkZXEydmgvc2NodWxtYW4tb2NoLXNhbm5pbmdlbi5tcDM=">  <div class="kv-pod-holder-inner">    Laddar <span class="blink-me">...</span>  </div></div>  <div class="kv-listen-subscribe">    <span>Följ Kvartals poddar:</span>    <a target="_blank" href="https://podcasts.apple.com/se/podcast/kvartal/id1447122576?mt=2">Apple</a>    |     <a target="_blank" href="https://open.spotify.com/show/6NsieE1iFLypikr3slKII0?si=ppaUJpA3R-mo8L9L4XgudA">Spotify</a>  </div></div><div class="kvartal-meta clearfix" style="color: "><div style="float: right;" class="social-top-wrapper closed no-comments"><div class="share-icons"><span class="share-outer"><a href="https://www.facebook.com/sharer.php?u=https%3A%2F%2Fkvartal.se%2Fartiklar%2Fschulman-och-sanningen%2F&amp;t=Schulman+och+sanningen"    target="_blank"    class="fb-link"    title="Dela på facebook"><i class="fa fa-facebook ui transparent"></i></a><a href   = "https://twitter.com/intent/tweet?text=Schulman+och+sanningen+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fschulman-och-sanningen%2F"    target = "_blank"    class  = "tw-link"    title  = "Dela på X.com"><i class="exticon exticon-x-icon"></i></a></span><span class="share-inner"><a href   = "http://www.linkedin.com/shareArticle?mini=true&url=https%3A%2F%2Fkvartal.se%2Fartiklar%2Fschulman-och-sanningen%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Schulman och sanningen&body=https://kvartal.se/artiklar/schulman-och-sanningen/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/91667/utskrift"    target  = "_blank"    class   = "pr-link"    title   = "Skriv ut"    onclick = ""><i class="ti-printer ui transparent"></i></a><a href   = "https://kvartal.se/skriv-ut/91667/pdf"    target = "_blank"    class  = "pr-link"    title  = "Ladda ner artikeln som PDF"><i class="fas fa-file-pdf ui transparent"></i></a></span><a href="#share" class="share-expand "    title="Visa fler delningsalternativ"><i class="fas fa-share-square ui transparent"></i></a></div></div></div><div class="author-section ">  <div class="author-section-inner">    <div class="author-image-holder"><div class="author-image" style="background-image: url('https://kvartal.se/wp-content/uploads/2022/10/LAPI.jpg');"></div><img class="author-print-img" src="https://kvartal.se/wp-content/uploads/2022/10/LAPI.jpg" style="display: none;">    </div>    <div class="by-disclaimer-holder" style="color: #8a3a67">Av <a href="https://kvartal.se/medverkande/lapo-lappin/">Lapo&nbsp;Lappin</a> | 31 mars 2023<div class="author-desc">Lapo Lappin är kulturskribent med bakgrund inom filosofin och medarbetare i Kvartals redaktion.
</div>    </div>  </div></div><div class="mobile-share clearfix" style="margin-top: -10px; margin-bottom: 20px;"><div class="share-icons"><span class="share-outer"><a href="https://www.facebook.com/sharer.php?u=https%3A%2F%2Fkvartal.se%2Fartiklar%2Fschulman-och-sanningen%2F&amp;t=Schulman+och+sanningen"    target="_blank"    class="fb-link"    title="Dela på facebook"><i class="fa fa-facebook ui transparent"></i></a><a href   = "https://twitter.com/intent/tweet?text=Schulman+och+sanningen+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fschulman-och-sanningen%2F"    target = "_blank"    class  = "tw-link"    title  = "Dela på X.com"><i class="exticon exticon-x-icon"></i></a></span><span class="share-inner"><a href   = "http://www.linkedin.com/shareArticle?mini=true&url=https%3A%2F%2Fkvartal.se%2Fartiklar%2Fschulman-och-sanningen%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Schulman och sanningen&body=https://kvartal.se/artiklar/schulman-och-sanningen/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/91667/utskrift"    target  = "_blank"    class   = "pr-link"    title   = "Skriv ut"    onclick = ""><i class="ti-printer ui transparent"></i></a><a href   = "https://kvartal.se/skriv-ut/91667/pdf"    target = "_blank"    class  = "pr-link"    title  = "Ladda ner artikeln som PDF"><i class="fas fa-file-pdf ui transparent"></i></a></span><a href="#share" class="share-expand "    title="Visa fler delningsalternativ"><i class="fas fa-share-square ui transparent"></i></a></div></div><div class="article-actions"><a href="/profile" class="kv-aa-profile"><svg aria-hidden="true">  <use href="#tf-ti-user"></use></svg><span>Profil</span></a><a class="listen" href="https://kvartal.se/artiklar/schulman-och-sanningen/?inlast=1">  <i class="fas fa-headphones-alt"></i>  <span>Inlästa texter</span></a><a href="#nyhetsbrevet" onclick="newsletter()" class="newsletter"><i class="fas fa-paper-plane"></i><span>Nyhetsbrev</span></a><a class="reading-time" title="Ungefärlig lästid"><i class="far fa-clock ui"></i><span>Lästid 41 min</span></a><a href   = "https://kvartal.se/skarmlasarvanlig/91667"    target = "_blank"    class  = "screen-reader-friendly"    title. = "Version som fungerar bättre med skärmläsarprogramvara">  <i class="fas fa-volume-up"></i>  <span>Skärmläsarvänlig</span></a></div><div class="in-short-wrapper closed" id="in-short-91667">  <div class="in-short-inner">    <span class="close_button close-in-short in-short-toggle" data-articleid = "91667"></span>    <i class="themify-icon-icon fas fa-align-left"></i>    <span class="in-short-heading">I korthet</span>    <hr class="in-short-divider" />    <div class="in-short-text">    </div>  </div></div><div class="article-beginning ">”Jag slarvar och skarvar, jag adderar och drar ifrån, därför att livet är en berättelse. Det viktigaste är att det <em>känns</em> sant.” Så säger den framgångsrike författaren och poddaren <strong>Alex Schulman</strong> i en intervju i P1.<sup>1</sup> Det citatet hade kunnat sammanfatta Schulmans inställning till sanningen, men så enkelt är det inte. Det finns också en annan Schulman. Han som insisterar på att det han skriver är sant och hänvisar till omfattande research. Den Schulman som hävdar att han är ”väldigt noga med att det ska vara sant”, som ”vinnlagt sig om att det ska vara dokumentärt”.<sup>2</sup> Det är när han pratar om romanen <em>Bränn alla mina brev</em> (2018) som handlar om Schulmans mormors otrohetsaffär med den kände publicisten Olof Lagercrantz.</p>
</div>
<div class="rest-of-article ">
<p>Men vad betyder det att säga att ”boken är sann”, som Schulman gör, när det rör sig om en roman?<sup>3</sup> Schulman är tydlig med att karaktärerna är gestaltade,<sup>4</sup> replikerna är fiktionaliserade,<sup>5</sup> att barndomsminnen är föränderliga.<sup>6</sup> Men ”de stora dragen är inte påhittade,” framhåller han ändå.<sup>7</sup> ”Allting som händer i boken grundar sig på källor som brev och dagböcker. Jag ville berätta sanningen om mina morföräldrar.”<sup>8</sup></p>
<p>Alltså: De stora dragen i Alex Schulmans bok är sanna, enligt Schulman.</p>
<p>Det är också så boken har tagits emot.<sup>9</sup> Recensenterna beskriver den som ”en roman om sanningssträvan”,<sup>10</sup> som ”känns väldigt sann”.<sup>11</sup> Boken ”kunde lika gärna ha kunnat placeras i bibliotekshyllan för biografier”, skriver tidskriften Opulens recensent.<sup>12</sup> Svensk Film (SF), som producerat filmversionen av <em>Bränn alla mina brev</em> (2022), marknadsför den som ”den sanna berättelsen om Karin Stolpe och hennes familj.”<sup>13</sup></p>
<blockquote><p>Det visar sig att<em> de stora dragen </em>i berättelsen som Schulman upprepat i åtskilliga intervjuer är fabulering och skarvningar.</p></blockquote>
<p>Eftersom sanningsenlighet är en av bokens säljande punkter försöker jag ta reda på vad som är sant och inte genom att titta på intervjuer med Schulman. Schulman upprepar gång på gång samma berättelse om hur boken blev till. Den handlar om hur han förvandlades till ”privatdetektiv”<sup>14</sup> (alternativt en ”<strong>Indiana Jones</strong>”) i jakten på källan till sitt eget mörker.<sup>15</sup>  Jag tänker att om något påstås på samma sätt både i boken och i minst en intervju – då måste det rimligen tolkas som att Schulman går i god för att det är sant. Allt annat i boken får Schulman artistisk licens på.</p>
<p>Sökandet leder Schulman till hans morfar <strong>Sven Stolpe</strong>, en konträr konservativ kulturpersonlighet ökänd för sitt heta temperament och för en livlig fantasi som han inte alltid kunde skilja från verkligheten. I Schulmans skildring har Stolpe få försonande sidor: han är ”en demon”,<sup>16</sup> ”urfadern av ondska”,<sup>17</sup> ”urmörkret”,<sup>18</sup> ”urondskan”.<sup>19</sup> Han är förklaringen till Schulmans dåliga sidor, och inte bara hans egna utan hela den dysfunktionella familjen i nedstigande led: ”På olika sätt förstörde Stolpe livet för sina barn”, skriver Schulman, ”och giftet rann ner i generationerna. Vi lärde oss alla att hata varandra och världen”.<sup>20</sup> Bara genom att gräva upp roten till denna arvsynd och låta den exponeras i offentlighetens ljus kan han häva förbannelsen, så att den inte går vidare även till Schulmans egna barn.</p>
<p>Schulman upptäcker ursprunget till Stolpes koleriska kynne genom att följa en rad ledtrådar. Den första är ett återkommande årtal i Stolpes memoarer, som förknippas med en livsomvälvande katastrof. Den andra ledtråden består i att Stolpe klottrade ner kryptiska anteckningar om en viss ”OL” genom hela sitt liv, hävdar Schulman.</p>
<p>Schulman sluter sig till att OL är <strong>Olof Lagercrantz</strong>, lyriker och kritiker som 1960 blev chefredaktör för Dagens Nyheter. Han upptäcker att Lagercrantz och Schulmans mormor, översättaren <strong>Karin Stolpe,</strong> hade en affär med tragiska följder när alla tre bodde samtidigt på Sigtunastiftelsen, ett gästhem där Sveriges mest framstående författare vistades.</p>
<p>Det visar sig att<em> de stora dragen </em>i berättelsen som Schulman upprepat i åtskilliga intervjuer är fabulering och skarvningar: ”ledtrådarna” är fabricerade, de ”autentiska breven” som boken baseras på (och som har varit en säljande punkt i marknadsföringen) är till stor del obefintliga i arkiven där de påstås finnas. Stolpes ”mordförsök” 1932 bygger på en bedräglig omtolkning av en bilolycka som i själva verket inträffade före Karin Stolpes otrohetsaffär med Lagercrantz. Historien om den eviga kärleken mellan Karin Stolpe och Olof Lagercrantz hänger på att Schulman låtsas som om att ett avgörande brev från Karin till Olof inte existerar.</p>
<figure id="attachment_91718" aria-describedby="caption-attachment-91718" style="width: 1234px" class="wp-caption alignnone"><img fetchpriority="high" decoding="async" class="wp-image-91718 size-full" src="https://kvartal.se/wp-content/uploads/2023/03/Brann-alla-mina-brev.jpeg" alt="" width="1234" height="1920" data-wp-pid="91718" srcset="https://kvartal.se/wp-content/uploads/2023/03/Brann-alla-mina-brev.jpeg 1234w, https://kvartal.se/wp-content/uploads/2023/03/Brann-alla-mina-brev-987x1536.jpeg 987w, https://kvartal.se/wp-content/uploads/2023/03/Brann-alla-mina-brev-600x934.jpeg 600w, https://kvartal.se/wp-content/uploads/2023/03/Brann-alla-mina-brev-193x300.jpeg 193w, https://kvartal.se/wp-content/uploads/2023/03/Brann-alla-mina-brev-768x1195.jpeg 768w" sizes="(max-width: 1234px) 100vw, 1234px" /><figcaption id="caption-attachment-91718" class="wp-caption-text"><em>Boken blev en succéfilm om: ”Den sanna berättelsen om Karin Stolpe och hennes familj”.  </em></figcaption></figure>
<p>Men vad spelar det för roll om Schulman fabulerar? Han har själv medgett att han brukar slarva och skarva. Och i de flesta fall spelar det säkert ingen roll alls. Han är ju ingen makthavare i klass med de politiker som han i en av sina DN-krönikor kritiserar för att ha varit med och skapat ”den obekymrade lögnens tidevarv”, människor som han menar har gjort ”lögnen [till] en naturlig del av kommunikationen”.<sup>21</sup></p>
<p>Men i vissa fall har Schulmans fantasier påverkan på verkliga människors liv. Som i fallet med eftermälet för Alex Schulmans morfar Sven Stolpe, en avliden offentlig person med gott om levande släktingar och bekanta. Schulman tar heder och ära av Stolpe genom att framställa honom som en mordisk sadist; han insisterar på att boken ger röst åt Stolpes förtryckta fru Karin. Schulmans karaktärsmord ger en falsk bild av historiska händelser.</p>
<h2>Den första ledtråden: Ett ”sexuellt attentat”</h2>
<p>Schulman börjar sin jakt efter sanningen genom att hävda att han plöjer Stolpes samtliga verk, upp mot 94 volymer.<sup>22</sup> Det blir tiotusentals sidor om vitt spridda ämnen, från fransk katolsk litteratur till 30-talets kulturdebatter, genom <strong>den heliga Birgitta</strong> och den ryskortodoxa teologen <strong>Nikolaj Berdjajev</strong>.<sup>23</sup> Märkligt nog har denna gigantiska bildningskatalog inte lämnat några spår i Schulmans egna texter.</p>
<p>När Schulman kommer till Sven Stolpes memoarer hittar han ett märkligt mönster.<sup>24</sup> Ett återkommande årtal, som Stolpe förknippar med en livsomvälvande katastrof: 1932. ”Året återkommer när Stolpe skriver om sitt liv. (&#8230;) <em>Sommaren 1932</em>.”<sup>25</sup></p>
<p>Jag införskaffar en bunt Stolpe-böcker från ett antikvariat och sätter igång med memoarerna. Jag hittar ingenting om sommaren 1932 någonstans.<sup>26</sup></p>
<p>Under sin läsning av memoarerna ramlar Schulman över ett uttryck som ”var så spännande att han nästan blev besatt av att få svar på vad det var som hade hänt den där sommaren.”<sup>27 </sup>Sven Stolpe hade lämnat en ledtråd till orsaken bakom sin livskris i en formulering: ”Sommaren 1932 utsattes jag för ett sexuellt attentat.”<sup>28 </sup></p>
<p>Detta ”underbart kränkta”<sup>29</sup> uttryck citeras i mer eller mindre alla uppslag om boken i medier.<sup>30</sup> Alex Schulman kommenterar det själv i en intervju: ”Det är så sjukt. Så typiskt Sven Stolpe att uttrycka det så.”<sup>31</sup></p>
<p>Till slut hittar jag formuleringen i memoaren <em>Idyll och orosmoln</em> (Askild &amp; Kärnekull, 1974). Men det som står där är något annat. Stolpe snuddar vid en händelse utan att gå in på detaljer, men nämner i förbifarten att det rör sig om ”ett sexuellt attentat av en samvetslös man mot en ung, förvirrad, gift kvinna som befann sig i fjärde månaden”.<sup>32</sup></p>
<p>Det är alltså inte Stolpe som är offret för attentatet, vilket Schulman låtit påskina. Det är också ytterst tveksamt om attentatsmannen är Olof Lagercrantz. Det är mer troligt att han syftar på en annan affär som Karin Stolpe hade senare med en annan man, 1935 eller 1936.</p>
<p>När jag läser Stolpes brev står det klart för mig att när han refererar till sin ”katastrof” så är det i själva verket sistnämnda händelse kring 1936 han har i åtanke, och inte affären med Lagercrantz fyra år tidigare.<sup>33</sup> Det styrks av brev från Stolpe till bland annat förläggaren <strong>Kaj Bonnier </strong>där han sommaren 1936 beskriver hur han blivit förkrossad av att frun haft en affär med en man som han namnger. Det är inte Olof Lagercrantz. Stolpe beskriver där hur denna otrohetsaffär inträffar nio månader före hans första dotters födelse, vilket leder till uppslitande scener där Karin får panikanfall och han själv känner sig mer död än levande. I Sven Stolpes brev från 1932 och de följande åren finns inga tecken på att Stolpe över huvud taget skulle ha känt till Karins och Olofs romans.<sup>34</sup> Men i ett brev till översättaren Lennart Göthberg från 1945 skriver Stolpe att det 1936 inträffade en händelse som gjorde att han hamnade i ett ”andligt träsk”.</p>
<p>Jag blir lite konfunderad: är det Schulman själv som har fabricerat ett citat där Stolpe säger sig ha blivit utsatt för ett sexuellt attentat? Och sedan  – i Sveriges Radio – menat att det är ”så jävla coolt uttryckt”?<sup>35</sup></p>
<h2>Den andra ledtråden: Mystiska initialer</h2>
<p>I jakt på att avslöja Sven Stolpes sexuella terrorist hamnar Schulman på Uppsala universitetsbibliotek. Schulman går genast i klinch med biblioteket, som inte lämnar ut hela arkiv på en och samma gång.<sup>36</sup> Men Schulman får (enligt berättelsen) sin vilja igenom och sitter med hela produktionen, låda efter låda,<sup>37</sup> omringad av kartong efter kartong av Sven Stolpes ”brev, mappar, lappar, anteckningar, foton, dagböcker”.<sup>38</sup></p>
<p>Inför mitt besök på biblioteket frågar jag om någon någonsin har begärt ut hela Stolpe-arkivet på samma gång. ”Jag har mycket svårt att tänka mig att vi någonsin tagit fram hela arkivet,” svarar en bibliotekarie ”då arkivet är 133 kapslar.” När jag kommer till specialläsesalen några dagar senare frågar jag ytterligare en anställd. Hon försvinner ner i bibliotekets innandöme för att kontrollera hur mycket material det rör sig om. Efter ett tag stiger hon tillbaka till ytan. ”Det är fysiskt omöjligt,” säger hon bestämt.</p>
<p>Alex Schulman skriver att han sätter sig ner bland materialet och ”börjar med det som är festligast”, bland annat Sven Stolpes brev till<strong> Astrid Lindgren</strong>.<sup>39</sup> Jag bestämmer mig för att också börja där, men märker snart att det inte finns några brev från Stolpe till Lindgren. Jag letar vidare efter andra brev som Schulman påstår sig ha läst: ”ursinniga brev till finansministern <strong>Gunnar Sträng</strong>”.<sup>40</sup> Varken jag eller bibliotekarierna finner dem. ”De infernaliska, hatiska breven till <strong>Eyvind Johnson</strong>.” Ingenting.<sup>41</sup></p>
<p>Schulman hävdar hur som helst att han läser alla Stolpes 7000 brev som är samlade på arkivet i Uppsala.<sup>42</sup> Han märker att två initialer – OL – återkommer ständigt i ”kryptiska ångestladdade anteckningar”.<sup>43</sup> I Sveriges Radio berättar Schulman att han hittar en anteckning: ”Träffar OL Stallmästaregården med sedvanligt resultat: kräkningar, illamående, yrsel.”<sup>44</sup> I romanen lyder citatet: ”Träffade OL med sedvanligt resultat: kris, apati, förtvivlans bön.”<sup>45</sup></p>
<p>Ständigt denna OL. En person som Alex Schulman ”till sist” räknar ut måste vara Olof Lagercrantz.<sup>46</sup></p>
<figure id="attachment_91712" aria-describedby="caption-attachment-91712" style="width: 1122px" class="wp-caption alignnone"><img decoding="async" class="wp-image-91712 size-full" src="https://kvartal.se/wp-content/uploads/2023/03/Bild-fickdagbok.jpeg" alt="" width="1122" height="1496" data-wp-pid="91712" srcset="https://kvartal.se/wp-content/uploads/2023/03/Bild-fickdagbok.jpeg 1122w, https://kvartal.se/wp-content/uploads/2023/03/Bild-fickdagbok-600x800.jpeg 600w, https://kvartal.se/wp-content/uploads/2023/03/Bild-fickdagbok-225x300.jpeg 225w, https://kvartal.se/wp-content/uploads/2023/03/Bild-fickdagbok-768x1024.jpeg 768w" sizes="(max-width: 1122px) 100vw, 1122px" /><figcaption id="caption-attachment-91712" class="wp-caption-text">Foto: Lapo Lappin.</figcaption></figure>
<p>Jag hittar anteckningen i en fickdagbok i brunt läder från 1950.<sup>47</sup> Men jag fattar vem det rör sig om betydligt fortare än vad Schulman verkar ha gjort. Ty det står skrivet: ”Middag Stallmästaregården.<em> Olof Lagercrantz närvarande</em>.”</p>
<p>Anteckningen fortsätter: ”Sedvanligt resultat: Kris, apati, förtvivlan, bön.”<sup>48</sup> (Citatet är inte exakt återgivet i romanen heller, men det får man tillskriva poetisk frihet).</p>
<figure id="attachment_91711" aria-describedby="caption-attachment-91711" style="width: 1920px" class="wp-caption alignnone"><img decoding="async" class="wp-image-91711 size-full" src="https://kvartal.se/wp-content/uploads/2023/03/1950-Ill-Lapo-Lagercrantz-Stolpe-Stallmastaregarden-20230216_145143.jpeg" alt="" width="1920" height="1440" data-wp-pid="91711" srcset="https://kvartal.se/wp-content/uploads/2023/03/1950-Ill-Lapo-Lagercrantz-Stolpe-Stallmastaregarden-20230216_145143.jpeg 1920w, https://kvartal.se/wp-content/uploads/2023/03/1950-Ill-Lapo-Lagercrantz-Stolpe-Stallmastaregarden-20230216_145143-1536x1152.jpeg 1536w, https://kvartal.se/wp-content/uploads/2023/03/1950-Ill-Lapo-Lagercrantz-Stolpe-Stallmastaregarden-20230216_145143-1200x900-cropped.jpeg 1200w, https://kvartal.se/wp-content/uploads/2023/03/1950-Ill-Lapo-Lagercrantz-Stolpe-Stallmastaregarden-20230216_145143-600x450.jpeg 600w, https://kvartal.se/wp-content/uploads/2023/03/1950-Ill-Lapo-Lagercrantz-Stolpe-Stallmastaregarden-20230216_145143-300x225.jpeg 300w, https://kvartal.se/wp-content/uploads/2023/03/1950-Ill-Lapo-Lagercrantz-Stolpe-Stallmastaregarden-20230216_145143-768x576.jpeg 768w" sizes="(max-width: 1920px) 100vw, 1920px" /><figcaption id="caption-attachment-91711" class="wp-caption-text"><em>Ur Sven Stolpes almanacka från 1950. Foto: Lapo Lappin/Uppsala universitetsbibliotek.</em></figcaption></figure>
<p>Jag letar vidare efter de mystiska initialerna. Schulman citerar ur ett brev från Sven till Karin från 1952.<sup>49</sup> Men detta brev existerar inte i arkivet.<sup>50</sup> Inte heller finns något spår av ett tredje brev där initialerna ska förekomma, från 1957, trots att jag läser samtliga brev i arkivet som Sven Stolpe har skickat till andra personer, sammanlagt flera hundra stycken.<sup>51</sup></p>
<p>Jag letar vidare. Schulman menar även att Sven Stolpe som 65-åring<sup>52</sup> (alternativt som 70-åring)<sup>53</sup> klottrat ned i sin almanacka att han hade återkommande mardrömmar om OL. ”OL förföljer mig i mina drömmar”.<sup>54</sup> Jag tittar igenom samtliga almanackor.<sup>55</sup> Det finns ingenting om ”OL”.<sup>56</sup></p>
<p>De som har recenserat <em>Bränn alla mina brev </em>verkar överens om att Schulmans omfattande <em>research </em>bygger på ”befintligt arkivmaterial”.<sup>57</sup> Men här verkar arkivmaterialet vara något mindre – så att säga – befintligt.</p>
<p>Bortsett från detta finns det även något slags anomali i hur medier har rapporterat om boken: Schulman ”upptäcker en familjehemlighet”,<sup>58</sup> ”avslöjar detaljerna”<sup>59</sup> och ”sanningen om sina morföräldrar”.<sup>60</sup> I själva verket finns det inte särskilt mycket att upptäcka, eftersom det rör sig om världens sämst bevarade familjehemlighet. Karin Stolpes affär med Olof Lagercrantz har tröskats i <strong>Stina Otterberg Engdahls</strong> avhandling om Olof Lagercrantz (2010) och i idéhistorikern <strong>Svante Nordins </strong>intellektuella biografi om Sven Stolpe (Atlantis, 2014).<sup>61</sup> Schulman hade inte behövt fabricera bevis.</p>
<figure id="attachment_91713" aria-describedby="caption-attachment-91713" style="width: 1920px" class="wp-caption alignnone"><img decoding="async" class="wp-image-91713 size-full" src="https://kvartal.se/wp-content/uploads/2023/03/Sigtunastiftelsen.jpeg" alt="" width="1920" height="1440" data-wp-pid="91713" srcset="https://kvartal.se/wp-content/uploads/2023/03/Sigtunastiftelsen.jpeg 1920w, https://kvartal.se/wp-content/uploads/2023/03/Sigtunastiftelsen-1536x1152.jpeg 1536w, https://kvartal.se/wp-content/uploads/2023/03/Sigtunastiftelsen-1200x900-cropped.jpeg 1200w, https://kvartal.se/wp-content/uploads/2023/03/Sigtunastiftelsen-600x450.jpeg 600w, https://kvartal.se/wp-content/uploads/2023/03/Sigtunastiftelsen-300x225.jpeg 300w, https://kvartal.se/wp-content/uploads/2023/03/Sigtunastiftelsen-768x576.jpeg 768w" sizes="(max-width: 1920px) 100vw, 1920px" /><figcaption id="caption-attachment-91713" class="wp-caption-text"><em>Det kan inte ha gått till som i filmen på Sigtunastiftelsen. Foto: Lapo Lappin.</em></figcaption></figure>
<p>Jag går vidare i Schulmans fotspår. Denna gång till Sigtunastiftelsen, där triangeldramat ska ha utspelat sig. Jag välkomnas av stiftelsens kommunikationschef, <strong>Sofia af Geijerstam</strong>. Hon berättar att jag inte är den första som kommer till Sigtunastiftelsen med romanen i handen. Bokens fans vallfärdar till Sigtuna för att uppleva miljöerna och söka spår av romankaraktärerna.</p>
<p>Vi klättrar upp till Tornrummet och blickar ut över Mälaren och medeltida kyrkoruiner. Kommunikationschefen betonar på en gång att skildringen i boken är fiktionaliserad. I boken får Schulman en visning runt stiftelsen av en tafatt värd. Så vitt någon på stiftelsen vet finns inte den personen i verkligheten.</p>
<p>Kommunikationschefen tittar på mig. Jag känner en artig misstänksamhet stråla åt mitt håll, förmodligen på grund av det absurda i att ”faktagranska en roman”. Lite som karaktärerna i <strong>Jorge Luis Borges</strong> <em>Tlön, </em>som kompilerar en encyklopedi om en påhittad värld.</p>
<p>Jag försöker förklara att det inte är romanen som sådan som jag är intresserad av. Visst finns det frågor om hur långt autofiktionen bör gå – får man till exempel anklaga någon för fruktansvärda brott?</p>
<p>Men det intressanta med Schulmans fall är att han i åtskilliga intervjuer och framträdanden har upprepat påståenden i boken som sanning. Det kan man inte hänföra till konstnärlig frihet.</p>
<p>Vi går ut i rosenträdgården, omfamnade av Sigtunastiftelsens gula murar. Härifrån får jag se rummen från utsidan. Det är där en av bokens mest filmiska scener utspelar sig, den första som Alex Schulman tecknade ned på papper.<sup>62</sup> ”Jag vet att detta äger rum”, säger han i Sveriges Radio: Karin och Olof ligger i sängen med kläderna på och lyssnar efter knattret från Svens skrivmaskin från våningen ovan, där han författar ett teatermanus i biblioteket.<sup>63</sup> Schulman har i intervjuer sagt att detta står i Olof Lagercrantz dagbok.<sup>64</sup> När jag står här är det svårt att få ihop det: gästrummen ligger på motsatt sida pelargången gentemot biblioteket. Under biblioteket fanns det 1932 inga rum, bara ett kapell. Nåja, det får anses vara en detaljfråga, jag går vidare.</p>
<p>Jag snappar även upp något annat när jag är på Sigtunastiftelsen. Personalen minns när Schulman besökte stiftelsen för ett författarsamtal 2019. Han har även talat om eventet i <em>Alex och Sigges podcast</em>, som finalen på ett invecklat epos.<sup>65</sup> Det börjar med att Schulman spiller ”världens godaste olivolja” på sina byxor, så att det ser ut som en kissfläck. Han försöker kamouflera fläcken genom att marinera skrevet i lite mer olja – men oljan innehåller nötter, vilket gör att en dam får ett allergianfall under panelsamtalet. Hennes man börjar då skrika: ”Är det någon här inne som äter nötter? Plocka bort nötterna!” Kvinnan hyperventilerar och måste ledas ut.</p>
<p>Personalen var också här under författarsamtalet, men är helt säker på att detta aldrig har inträffat.</p>
<h2>Alexanders korståg i Mjölby</h2>
<p>Det finns en sista anekdot från Schulman som jag vill ha utredd innan jag kan gå vidare till det stora tragiska klimaxet i Schulmans berättelse om Karin och Olof.</p>
<p>Det är en historia som Alex Schulman har berättat i åtskilliga intervjuer, i sin podd samt i två böcker. Den utspelar sig på Mjölby gymnasium (och inte, som han själv skriver, ”Mjölby folkhögskola” eller ”Mjölby universitet”),<sup>66</sup> där Sven Stolpe började arbeta som lektor 1964 (och inte som Schulman skriver 1967).<sup>67</sup> Alex’ mor <strong>Lisette</strong> gick på skolan samtidigt, där hon blev tillsammans med pojken <strong>Bosse</strong>, som Schulman brukar beskriva som en ”bondgrabb” (en missvisande beskrivning som särskilt retar upp dem som kände honom på den tiden).<sup>68</sup> Sven Stolpe ska ha misstyckt till relationen och visat detta ”med önskvärd tydlighet”.<sup>69</sup></p>
<p>Schulman har gett motstridiga versioner av hur han fått kännedom om denna anekdot. I oktober 2016 berättar han att han först hörde historien från sin bror <strong>Calle Schulman</strong> ”för bara några månader sedan.”<sup>70</sup> När Schulman blir pressad i programmet <em>Min sanning</em> i SVT blir det något som Alex Schulmans mamma Lisette berättade för honom, två år innan hon avled (februari 2015).<sup>71</sup> Nu, när jag börjat fråga runt om händelsen, säger han i sin podd, är det något som Lisette berättade ”för oss barn”, i pluralis, ”vid ett flertal tillfällen (&#8230;) när hon var nykter”.<sup>72</sup></p>
<p>Även själva anekdoten återkommer i ett flertal skepnader. I boken <em>Glöm mig</em> berättas att Lisette Schulman en dag kommer in till Mjölby gymnasium och ser en lapp på anslagstavlan, skriven med Stolpes handstil. Det står: “LISETTE STOLPE ÄR EN HORA”. Lisette river ner den, men när hon tittar upp är det lappar i alla korridorer. Folk ropar ”hora” efter henne. Dagen efter är det lappar överallt igen; dagen därpå är det samma sak. Hon tar upp det med rektorn, som uppmanar henne och Bosse att byta skola. De följer hans råd.<sup>73</sup> Schulman ”är säker på att historien är sann”.<sup>74</sup></p>
<p>Det finns även andra varianter: ibland är det bara en lapp på anslagstavlan, ibland är de uppsatta på hela skolan. Ibland utspelar sig episoden över två, eller tre, eller fyra dagar. Det slutar alltid med att de måste byta skola på rektorns uppmaning.<sup>75</sup></p>
<p>Jag kontaktar en av Lisette Schulmans närmaste gymnasiekompisar – <strong>Hans Månson</strong> – för att stämma av vilken version som gäller. Han frågar mig: ”Vet du vem jag är?”</p>
<p>Jag förstår inte frågan helt, men svarar att jag vet att han kände Lisette (och var tidigare chefredaktör på Sydsvenskan). Månson vill inte svara på rak arm och säger att han måste fundera på saken.</p>
<p>Dagen efter ringer Månson upp igen och säger att han kan sätta mig i kontakt med någon som kan bekräfta att det har hänt. Han ger mig numret till sin exfrus halvbror: Alex Schulman.</p>
<p>Schulman berättar några dagar senare om mina efterforskningar i <em>Alex och Sigges podcast</em>. Han beskriver även hur jag har gått tillväga. Han säger att jag ”har pratat med alla i mammas klass och andra som gick i skolan och gjort noggranna intervjuer med dem och frågat: minns du någonting om det här? Ingen av dem minns detta.”<sup>76</sup></p>
<p>Jag har redan fått en känsla för hur Alex Schulman jobbar, men det är ändå overkligt när jag själv blir föremål för detta. Vid den tidpunkten hade jag haft kontakt (i det ena fallet ytterst kortfattat) med endast två personer som hade gått på Mjölby gymnasium.</p>
<p>Schulman lovar dessutom i podden att han kan sätta mig i kontakt med Lisettes dåvarande pojkvän Bosse, som han vet är vid liv.<sup>77</sup> Men jag vet att Bosse avled 2021.</p>
<p>Jag tar i stället kontakt med Bosses dotter. Hon har inte hört talas om att de skulle ha slutat på skolan, men kände igen historien om att det skulle ha hängt lappar i korridorerna. Jag försöker kontakta andra som gick på Mjölby gymnasium samtidigt och som kan intyga saken. Ingen minns lapp-incidenten (inte ens Hans Månson). Tvärtom verkar alla fullständigt övertygade om att det är en skröna. Medlemmar i lärarkåren menar att de hade fått veta det om rektorn faktiskt hade blivit inkopplad. Gymnasievänner till Lisette är säkra på att hon aldrig bytte skola och säger att hon skulle ha berättat detta för dem om det hade hänt. De upplever att Alex Schulman har varit ointresserad av att stämma av med dem huruvida det verkligen hände. Det hela har till och med fått ett namn i Mjölbykretsar – ”Alexanders korståg”, kallar man det.</p>
<h2>Stolpe i diket</h2>
<p>Karins och Olofs affär trappas upp till ett klimax, ”ett onämnbart våldsdåd” som DN beskriver det i artikeln ”Varför är Alex Schulman rasande?”.<sup>78</sup> I Sveriges Radio förklarar Schulman hur saker gick till: ”Morfar kommer på dem. Han är ju galen. Han blir väldigt mörk, och borde egentligen ha hamnat i fängelse för det han gjorde. Han försökte döda henne, och var väldigt nära att lyckas.”<sup>79 </sup>”Det är av stor vikt att jag får veta sanningen”, skriver Schulman om denna historia i <em>Bränn alla mina brev. </em><sup>80</sup></p>
<p>Han kommer fram till att sanningen, enligt vad Schulman berättat i intervjuer, är att Stolpe körde av vägen och utför ett stup i hög fart för att döda sin fru till följd av affären med Lagercrantz.<sup>81</sup> Hon blev allvarligt skadad: hennes ”ansikte fattade eld, hon fick tredje gradens brännskador över bröstkorgen och halsen”.<sup>82</sup> Schulman beskriver händelsen som ”atombomben” som förändrar allt för familjen, källan till det mörker som Alex bär på.</p>
<p>Bilolyckan som Schulman beskriver är väldokumenterad. Det finns till och med en notis i Dagens Nyheter: ”Författaren Stolpe kör i diket med sin fästmö”, datumet är den 26 maj 1931.<sup>83</sup> Olyckan skedde ett år innan Karin Stolpe träffar Olof Lagercrantz 1932. Karins allvarliga skador kommer däremot från en annan incident tio år senare (1942), då en gasbehållare antändes vid matlagning och exploderade.<sup>84</sup></p>
<figure id="attachment_91714" aria-describedby="caption-attachment-91714" style="width: 1535px" class="wp-caption alignnone"><img decoding="async" class="wp-image-91714 size-full" src="https://kvartal.se/wp-content/uploads/2023/03/DN-31-Bilolyckan-Stolpe-Karin.jpg" alt="" width="1535" height="1920" data-wp-pid="91714" srcset="https://kvartal.se/wp-content/uploads/2023/03/DN-31-Bilolyckan-Stolpe-Karin.jpg 1535w, https://kvartal.se/wp-content/uploads/2023/03/DN-31-Bilolyckan-Stolpe-Karin-1228x1536.jpg 1228w, https://kvartal.se/wp-content/uploads/2023/03/DN-31-Bilolyckan-Stolpe-Karin-600x750.jpg 600w, https://kvartal.se/wp-content/uploads/2023/03/DN-31-Bilolyckan-Stolpe-Karin-240x300.jpg 240w, https://kvartal.se/wp-content/uploads/2023/03/DN-31-Bilolyckan-Stolpe-Karin-768x961.jpg 768w" sizes="(max-width: 1535px) 100vw, 1535px" /><figcaption id="caption-attachment-91714" class="wp-caption-text"><em>DN skrev om bilolyckan 1931, ett år innan Karin träffade Olof.</em></figcaption></figure>
<p>Som en följd av kritik från litteraturprofessorn <strong>Lars Lönnroth</strong> på Facebook 2019<sup>85</sup> har Alex Schulman på senare tid ändrat hållning. Den enda gången han har bemött Lönnroths kritik direkt är vid Bokmässan i Göteborg 2019.<sup>86</sup> Då medger han att han ”gjorde om lite i kronologin”<sup>87</sup> och undrar varför folk ondgör sig så mycket över detta.</p>
<p>Schulman har dock, så sent som hösten 2022, påstått i intervjuer till tyska och danska journalister att sanningen är att Stolpe försökte mörda sin fru till följd av Lagercrantz-affären. Detta sker alltså <em>efter</em> han medgett att han pusslat om i kronologin.<sup>88</sup></p>
<p>På andra håll menar Schulman att han inte har något tvivel om att Stolpe ändå försökte mörda sin fru, fast då menar han att mordförsöket inträffade ett år tidigare än i boken.<sup>89</sup> Han grundar detta på två saker: dels att han säger att händelsen är omnämnd i Olof Lagercrantz’ dagbok från 1932, dels i ett brev från Sven Stolpe till sin mamma från 1931.</p>
<h2>Litteraturprofessor: Schulman ljuger</h2>
<p>Jag försöker därför få tag på dagboken för att kunna bekräfta att Schulmans uppgifter stämmer. Men Olofs son <strong>Richard Lagercrantz </strong>vägrar ge mig tillgång till materialet. Jag mejlar då Alex Schulman själv och ber honom låta mig ta del av dagboken. Han svarar att han har lovat att inte föra vidare den till någon. ”Men det finns där, tro mig”, skriver han. Jag kontaktar därför litteraturprofessorn <strong>Lars Lönnroth </strong>(tillika Olof Lagercrantz&#8217; systerson), som också har läst materialet. Han har inget minne av att det skulle ha stått något där om att Sven Stolpe hade försökt mörda sin fru, och menar att han hade kommit ihåg så sensationella uppgifter. Lönnroth mejlar till mig att Schulman ”sannolikt ljuger, medvetet eller omedvetet.” Han har godkänt att jag citerar det.</p>
<p>Vid ett tillfälle i <em>Bränn alla mina brev </em>agerar Schulman själv djävulens advokat och uttrycker tvivel kring Olofs version av händelserna. Olof kanske ”målar upp en bild av Sven som ett monster för att rättfärdiga sin kärleksaffär”? ”För att vara helt säker krävs ett erkännande från Sven” fortsätter Schulman. Han hittar detta bevis i ovannämnda brev från Stolpe till dennes mor, skrivet efter att han kört av vägen. I sin podcast säger Schulman: ”Sven Stolpe berättade för sin mamma att han gjorde det med flit, när han bad om pengar för att få köpa en ny bil, eller för att reparera den där bilen. Därför att han ville döda sig själv och mormor av svartsjuka.”<sup>90</sup></p>
<p>Jag hittar brevet från Stolpe till hans mamma och läser det. Det är från tiden före bröllopet mellan Sven och Karin 1931. Men ingenstans nämns något om pengar, om att köpa en ny bil eller reparera den gamla. Inte heller något erkännande om att han försökte döda Karin. Eller något uttryckligen om svartsjuka över huvud taget. Men brevet sticker ut på många sätt. Tonläget är uppskruvat, frågetecken och utropstecken staplas på varandra, ibland två eller tre i rad. Stolpe svarar på ett brev från modern där han anklagas för ytlighet, flärdfullhet, egoism, självrättfärdighet, ansvarslöshet samt att han alltid skyller ifrån sig. Han besvarar alla anklagelserna en efter en och säger emot mamman på samtliga punkter. Brevet antyder att något har skett mellan Sven och Karin, men att mamman aldrig ska få veta vad det är. Det framgår tydligt att han finner moderns kritik absurd. Till sist kommer Stolpe till punkten ”ansvarslöshet i bilolyckan”. Även här ryter han ifrån till sin mor: ”Hmm. Om det hela var avsiktligt då? Om jag i desperation och förtvivlan körde i diket självmant? Om jag tänker göra om saken så fort jag får ut bilen?”<sup>91</sup> Stolpe avslutar brevet med att skriva: ”Jag orkar inte fortsätta. [&#8230;] Om jag verkligen förefaller mamma så dålig, så släpp mig.”</p>
<p>Är detta ”ett erkännande” om att han försökte ta livet av sig och sin fru? Eller är det retoriska frågor skrivna i affekt?</p>
<p>Räcker det här för att utmåla en människa som ett mordiskt monster?</p>
<div class = "kv-cruta closed grey cr-round "      id    = "cruta-PsTFWwdcNi"></p>
<h3 style="text-align: center;"><a href="https://kvartal.se/wp-content/uploads/2023/03/brev-stolpe-.pdf"><strong>Brevet går att läsa i sin helhet här &gt;&gt;</strong></a></h3>
<p></div>
<p>Jag hittar den sista pusselbiten i Kungliga Bibliotekets specialläsesal i Stockholm. Jag trodde inte det skulle finnas något av särskilt intresse i Olof Lagercrantz’ arkiv, eftersom Schulman har berättat att han fått Karins brev till Olof från Richard Lagercrantz personligen.<sup>92</sup> Men det visar sig att Karins brev till Olof faktiskt förvaras här. Utöver kärleksbreven från 1932, som Schulman brukar citera, finns det ett brev från 1935 där tonen är annorlunda. Karin skriver till Olof att hon vill ”klargöra” det som hänt dem emellan: ”Jag var nog egoistisk att ta emot din kärlek utan att ge någonting igen. Jag menar med ‘något’ något helt och övertygat. Om jag varit hel i mina känslor så hade jag väl också velat ge mig åt dig. Men jag ville det aldrig, bara drogs med av din kärlek.”</p>
<blockquote><p> I mitt äktenskap har jag fått mer än jag förtjänat, på alla sätt.</p></blockquote>
<p>Hon fortsätter: ”Jag kommer inte ihåg vilka illojala saker jag sade till dig om Sven, men naturligtvis var det en del; jag var ju i färd med att bedraga honom och behövde alltså försvara mig. Alltsammans är vidrigt i detta.”</p>
<p>Jag undrar varför Schulman aldrig nämner detta brev. Kanske för att det ska bli den bitterljuva berättelsen om evig oförverkligad kärlek som Schulman vill ha. Kanske för att Karin där antyder att hon svartmålat Sven inför Olof, för att rättfärdiga deras affär. Men om avsikten var, som Schulman påstår, att ”berätta sanningen” om sina morföräldrar, verkar Karins slutsats i det sista brevet till Olof vara värd att ta i beaktande: ”Facit: du valde mig och ville stå för det, men jag hade inte valt dig och ville inte stå för något alls när det kom till kritan. Däremot hade jag valt Sven. I mitt äktenskap har jag fått mer än jag förtjänat, på alla sätt.”<sup>93</sup></p>
<p>Men att berätta sanningen är i detta fall mindre viktigt att än att väva ihop en bra <em>story </em>och sedan marknadsföra den som fakta. Schulman påstår att syftet med boken är att äntligen ge Karin Stolpe en röst.<sup>94</sup> Men den verkliga Karin Stolpe tystas för alltid.</p>
<h2>När gränsen mellan sant och falskt suddas ut</h2>
<p>”Det viktiga är att det <em>känns</em> sant,” säger Alex Schulman i <em>Söndagsintervjun </em>i P1. Men han tillägger snabbt: ”Eller… det <em>är </em>sant!” Antagligen för att det är vad sanning betyder för Schulman: en magkänsla, det som faller en in som rimligt i stunden. Två motsägelsefulla påståenden kan vara sanna på en och samma gång; skeenden som aldrig inträffat kan vara sanna.<sup>95</sup> ”Lögnen har hunnit ifatt mig,” säger Schulman i podden, ”men det kan lika gärna vara sanningen.”<sup>96</sup> Gränsen mellan sanning och lögn är porös.<sup>97</sup> Lögnerna kan omvandlas till sanning och vice versa.</p>
<p>I <em>Bränn alla mina brev </em> beskriver karaktären Olof Lagercrantz gillande Sven Stolpe med snarlika formuleringar: ”Han uttrycker direkta felaktigheter med den största självsäkerhet … överdriver på ett så övertygande sätt att han till slut tror på det själv.”<sup>98</sup></p>
<p>”För mig går historierna före sanningen” säger Schulman i SVT:s <em>Min sanning</em>.<sup>99</sup> Detta verkar inte enbart appliceras på Schulmans autofiktiva romaner, där det kanske hade varit rimligt (men då utan hans ständiga anspråk på sanning). Det verkar gälla för hela Schulmans väsen; allt är fiktion, eftersom livet är en berättelse.<sup>100</sup></p>
<p>Men utanför Schulmans fantasivärld är skillnaden mellan vad som är sant och vad som bara råkar underhålla en väldigt viktig sådan. När gränserna mellan sant och falskt suddas ut rasar grunden för det offentliga samtalet. Schulman har systematiskt fört journalister och publik bakom ljuset. Medierna har svalt hans skrönor och fört dem vidare som sanning – ofta utan kritiska frågor, aldrig med så mycket som en faktagranskning.<sup>101</sup> Tre dagar efter att Alex Schulman säger att frågan om vad som är sant är ”så jävla knäpp” belönas han med Expressens pris för god kulturjournalistik.<sup>102</sup></p>
<p>Vi lever verkligen – som Schulman hade sagt – i den obekymrade lögnens tidevarv.</p>
<p style="text-align: center;">*</p>
<p><em>Lapo Lappin har upprepade gånger bett Alex Schulman om ett möte för en intervju inför denna artikel. Schulman har då svarat avvaktande och bett om att få frågorna i förväg. Efter att ha fått dessa mejlar han på torsdagskvällen följande svar: </em><em>Bränn alla mina brev är tydligt märkt på omslaget som en ”roman” och det är så den ska ses. Den bygger på verkliga händelser, men återigen: Den är skriven som en roman.</em></p>
<p><em>Det innebär till exempel att jag har skapat helt och hållet fiktiva dialoger mellan Karin Stolpe och Olof Lagercrantz, och mellan andra personer. Faktiska händelser har möblerats om och ändrat karaktär, jag har skruvat och vridit, överdrivit, underdrivit, lagt till och dragit ifrån. Boken är helt enkelt full av konstruktioner. Hade jag påstått att boken är en fakta-bok så hade jag varit illa ute om någon grävande reporter lika skicklig som du hade fått korn på mig. Men det har jag inte gjort. Jag kallar det för en roman. Det var viktigt för mig att göra det, just därför att jag ville ha den friheten.</em></p>
<p><em>Du invänder då och påpekar att jag pratat om boken i intervjuer, som om den VORE sann, som om den vore nåt annat än en roman, och du frågar mig: &#8221;Varför inte bara nöja sig med att säga att det är påhittat?”  Jo, det beror på att den faktiskt också ÄR sann. På riktigt sann, in i själen. Bränn alla mina brev handlar om två människor som blir förälskade på sådant sätt att båda deras liv kastas omkull. En kärlekshistoria utvecklas som sedan påverkar dem och människor omkring dem i decennier. Den historien är tveklöst autentisk, detta hände. Det är det jag har velat skildra.</em></p>
<p><em>Men, och med risk för att nu låta tjatig: Jag har gjort det i romanform. Jag skriver det på bokens omslag och för att vara helt säker på att en läsare förstår vad jag har försökt göra, så skriver jag dessutom i bokens efterord några rader som får bli den här kommentarens slutord:</em></p>
<p><em>&#8217;”Ibland har jag förenklat händelserna, andra gånger har jag ändrat i kronologin. Historien utgår från riktiga människor, den grundar sig i ett material som återger autentiska händelser, men det är också viktigt att säga: det är en roman.'&#8221;</em></p>
<div class="notes-wrapper"><a class="shadow-button noselect show-notes"  data-articleid="91667">  <span class="button-inner-wrapper">    <span class="left-part">      <i class="ti-arrow-circle-down"></i>    </span>    <span class="right-part">      <span class="default-text">Se noter</span>      <span class="open-text">Visa mindre</span>    </span>  </span></a></p>
<div class="references">
<h3 id="noter" class="ref-heading" style="color: #000;;">Noter</h3>
<p>1, <a href="https://sverigesradio.se/avsnitt/alex-schulman-jagar-den-perfekta-historien">https://sverigesradio.se/avsnitt/alex-schulman-jagar-den-perfekta-historien</a> 44:40.</p>
<p>2, <a href="https://sverigesradio.se/avsnitt/alex-schulman-jagar-den-perfekta-historien">https://sverigesradio.se/avsnitt/alex-schulman-jagar-den-perfekta-historien</a> 45:00</p>
<p>3, <a href="https://ljsp.lwcdn.com/api/video/embed.jsp?id=c652afa3-8f0e-4917-be57-2fddcf66fb58">https://ljsp.lwcdn.com/api/video/embed.jsp?id=c652afa3-8f0e-4917-be57-2fddcf66fb58</a>. Jmf. <a href="https://www.podplay.com/sv-se/podcasts/samtal-om-bocker-788772/episodes/1-alex-schulman-ar-en-av-overlevarna-70423794">https://www.podplay.com/sv-se/podcasts/samtal-om-bocker-788772/episodes/1-alex-schulman-ar-en-av-overlevarna-70423794</a>.</p>
<p>4, <a href="https://www.expressen.se/noje/schulman-skriver-bok-om-sin-mormors-karleksaffar-med-olof-lagercrantz/">https://www.expressen.se/noje/schulman-skriver-bok-om-sin-mormors-karleksaffar-med-olof-lagercrantz/</a>; <a href="https://www.podplay.com/sv-se/podcasts/samtal-om-bocker-788772/episodes/1-alex-schulman-ar-en-av-overlevarna-70423794">https://www.podplay.com/sv-se/podcasts/samtal-om-bocker-788772/episodes/1-alex-schulman-ar-en-av-overlevarna-70423794</a> 33:00. “I mina böcker om min barndom finns det hundratals repliker, men inget av detta är någonsin sagt egentligen. I alla fall inte ordagrant. Men jag kan skriva en bok med 500 lögnaktiga citat, och ändå ha skrivit en bok som är helt sann”.</p>
<p>5, <a href="https://sverigesradio.se/play/avsnitt/1188007">https://sverigesradio.se/play/avsnitt/1188007</a> ca. 35:00</p>
<p>6, <a href="https://www.podplay.com/sv-se/podcasts/samtal-om-bocker-788772/episodes/1-alex-schulman-ar-en-av-overlevarna-70423794">https://www.podplay.com/sv-se/podcasts/samtal-om-bocker-788772/episodes/1-alex-schulman-ar-en-av-overlevarna-70423794</a> 35:00; <a href="https://open.spotify.com/episode/3h2HP2p1qNVbsvPchgvYnR?si=HhIpt2yjTRiwqeLMgUvedw">https://open.spotify.com/episode/3h2HP2p1qNVbsvPchgvYnR?si=HhIpt2yjTRiwqeLMgUvedw</a> 34:00</p>
<p>7, <a href="https://ljsp.lwcdn.com/api/video/embed.jsp?id=c652afa3-8f0e-4917-be57-2fddcf66fb58">https://ljsp.lwcdn.com/api/video/embed.jsp?id=c652afa3-8f0e-4917-be57-2fddcf66fb58</a>.</p>
<p>8, ”<em>In diesem Buch basiert alles auf Tatsachen, alles was passiert beruht auf Quellen wie z.B. Tagebüchern und Briefen. Ich wollte in dieser Geschichte die Wahrheit über meinen Großvater und meine Großmutter erzählen.</em>” (<a href="https://buechermenschen.de/interview/exklusiv-interview-mit-alex-schulman/">https://buechermenschen.de/interview/exklusiv-interview-mit-alex-schulman/</a>).</p>
<p><em>9, Bränn alla mina brev </em>”bygger på helt autentiska brev och händelser” (<a href="https://www.expressen.se/noje/schulman-skriver-bok-om-sin-mormors-karleksaffar-med-olof-lagercrantz/">https://www.expressen.se/noje/schulman-skriver-bok-om-sin-mormors-karleksaffar-med-olof-lagercrantz/</a>); <em>Bränn alla mina brev </em>beskrivs som ”självbiografisk och verklighetsbaserad” (<a href="https://www.etc.se/kultur-noje/schulmans-historia-foer-litteraer-som-film">https://www.etc.se/kultur-noje/schulmans-historia-foer-litteraer-som-film</a>). I programmet <em>Babel </em>i SVT säger programledaren: ”En del berättelser är helt enkelt för bra för att vara osanna, och det är en sådan som Alex Schulman har grävt fram” (<a href="https://www.svtplay.se/video/e55Bb6e/babel/maria-aljochina-alex-schulman-och-loreen">https://www.svtplay.se/video/e55Bb6e/babel/maria-aljochina-alex-schulman-och-loreen</a> 1:20). Andra recensioner medger att det är otydligt vad som är fiktion och verklighet med drar likväl slutsatser om de verkliga personligheterna baserat på boken: <a href="https://www.opulens.se/opinion/dags-att-tala-klarsprak-om-mans-vald-mot-kvinnor/">https://www.opulens.se/opinion/dags-att-tala-klarsprak-om-mans-vald-mot-kvinnor/</a>, (<a href="https://www.sydsvenskan.se/2018-11-24/alex-schulman-skildrar-lyhort-sin-jakt-pa-familjens-svarta">https://www.sydsvenskan.se/2018-11-24/alex-schulman-skildrar-lyhort-sin-jakt-pa-familjens-svarta</a>).  Andra recensioner tar innehållet som pålitlig utan att problematisera: <a href="https://www.barometern.se/article/karlek-och-svek-i-schulmans-familj/">https://www.barometern.se/article/karlek-och-svek-i-schulmans-familj/</a>.</p>
<p>10, <a href="https://www.expressen.se/kultur/bocker/pa-jakt-efter-familjens-giftiga-vrede/">https://www.expressen.se/kultur/bocker/pa-jakt-efter-familjens-giftiga-vrede/</a></p>
<p>11, Ylva Nilsson i SR-radio: ”framför allt så känns det väldigt sant” (<a href="https://sverigesradio.se/artikel/7090511">https://sverigesradio.se/artikel/7090511</a>). Sanningskänslan resonerar även hos Therese Eriksson i <em>Expressen</em>, som skriver att ”<em>Bränn alla mina brev</em> känns som en sann bok” (<a href="https://www.expressen.se/kultur/bocker/pa-jakt-efter-familjens-giftiga-vrede/">https://www.expressen.se/kultur/bocker/pa-jakt-efter-familjens-giftiga-vrede/</a>).</p>
<p>12, <a href="https://www.opulens.se/litteratur/uppriktigt-om-nedarvd-vrede/">https://www.opulens.se/litteratur/uppriktigt-om-nedarvd-vrede/</a></p>
<p>13, <a href="https://web.archive.org/web/20230224122941/https:/www.sfanytime.com/sv/movie/brann-alla-mina-brev">https://web.archive.org/web/20230224122941/https://www.sfanytime.com/sv/movie/brann-alla-mina-brev</a></p>
<p>Likaså film-hemsidan Panora: ”Filmen [Bränn alla mina brev] följer den sanna historien om Alex Schulmans morföräldrar” (<a href="https://panora.se/filmer/brann-alla-mina-brev/">https://panora.se/filmer/brann-alla-mina-brev/</a>). Liknande tongångar från hemsidan <em>Månadens bok</em>, där <em>Bränn alla mina brev</em> beskrivs som ”En sann och drabbande kärlekshistoria som slår all fiktion”, (<a href="https://www.manadensbok.se/bocker/romaner/brann-alla-mina-brev-alex-schulman/">https://www.manadensbok.se/bocker/romaner/brann-alla-mina-brev-alex-schulman/</a>). På ljudboksplattformen <em>Nextstory</em> beskrivs boken så här: ”Med hjälp av autentiska brev och dagboksutdrag avtäcker han inte bara århundradets kärlekshistoria, utan även dess tragiska konsekvenser” (<a href="https://www.nextory.se/bok/br%C3%A4nn-alla-mina-brev-10088615/">https://www.nextory.se/bok/br%C3%A4nn-alla-mina-brev-10088615/</a>).</p>
<p>14, <a href="https://sverigesradio.se/play/avsnitt/1188007">https://sverigesradio.se/play/avsnitt/1188007</a> 33:30.</p>
<p>15, <a href="https://www.dn.se/kultur-noje/varfor-rasar-alex-schulman/">https://www.dn.se/kultur-noje/varfor-rasar-alex-schulman/</a></p>
<p>16, <a href="https://www.svd.se/a/WLMEW2/ar-breven-nyckeln-till-den-schulmanska-vreden">https://www.svd.se/a/WLMEW2/ar-breven-nyckeln-till-den-schulmanska-vreden</a></p>
<p>17, <a href="https://sverigesradio.se/play/avsnitt/1182959">https://sverigesradio.se/play/avsnitt/1182959</a></p>
<p>18, <a href="https://sverigesradio.se/play/avsnitt/1195241">https://sverigesradio.se/play/avsnitt/1195241</a></p>
<p>19, <a href="https://www.sydsvenskan.se/2018-11-06/alex-schulman-han-ar-urondskan">https://www.sydsvenskan.se/2018-11-06/alex-schulman-han-ar-urondskan</a></p>
<p>20, Alex Schulman, <em>Bränn alla mina brev,</em> s. 43.</p>
<p>21, <a href="https://www.dn.se/sverige/alex-schulman-vi-lever-i-den-obekymrade-lognens-tidevarv/">https://www.dn.se/sverige/alex-schulman-vi-lever-i-den-obekymrade-lognens-tidevarv/</a></p>
<p>22<a href="https://sverigesradio.se/play/avsnitt/1188007">https://sverigesradio.se/play/avsnitt/1188007</a> 30:20;</p>
<p><a href="https://www.hemtrevligt.se/hemmetsjournal/artiklar/artiklar/20181216/antligen-forstar-jag-upphovet-till-min-ilska/">https://www.hemtrevligt.se/hemmetsjournal/artiklar/artiklar/20181216/antligen-forstar-jag-upphovet-till-min-ilska/</a>; <a href="https://www.expressen.se/kultur/bocker/pa-jakt-efter-familjens-giftiga-vrede/">https://www.expressen.se/kultur/bocker/pa-jakt-efter-familjens-giftiga-vrede/</a>; <a href="https://www.hbl.fi/artikel/5db33f2d-a1f2-4cd9-8a70-52a07c108e28">https://www.hbl.fi/artikel/5db33f2d-a1f2-4cd9-8a70-52a07c108e28</a>; <a href="https://www.youtube.com/watch?v=ZbIwFkaOpc8">https://www.youtube.com/watch?v=ZbIwFkaOpc8</a>.</p>
<p>Ett återkommande tema i denna berättelse är att Schulman i intervjuer uppger att han ”aldrig har läst [Stolpe] förut, någonsin” (<a href="https://sverigesradio.se/play/avsnitt/1195241">https://sverigesradio.se/play/avsnitt/1195241</a> 52:50; jmf. <a href="https://www.youtube.com/watch?v=ZbIwFkaOpc8">https://www.youtube.com/watch?v=ZbIwFkaOpc8</a>). Men i Schulmans ikoniska intervju i <em>Bon </em>låter det så här: ”Vet du att jag läste en del grejer av [Sven Stolpe] nyligen och insåg att det finns ordföljder, satsmelodier, som jag måste ha ärvt av honom på nåt konstigt sätt. Samma flyt, samma ordval” (<a href="https://bon.se/magazine/bon-38/andra-sidan-alex/">https://bon.se/magazine/bon-38/andra-sidan-alex/</a>).</p>
<p>23, Stolpes fullständiga bibliografi finns i Svante Nordin, <em>Sven Stolpe: Blåsten av ett temperament </em>(Atlantis 2014), s. 295-298.</p>
<p>24, Det är antagligen den tyska <em>Ich blicke zurück – ich blicke voraus </em>(Knecht 1965), samt den svenska trilogin <em>Idyll och orosmoln </em>(Askild &amp; Kärnekull 1974), <em>Stormens år </em>(1975) och <em>Krigstid </em>(1976). Jag har lyckats spåra alla Schulmans citat (i någon form) till de tre första (det vill säga inte <em>Krigstid</em>).</p>
<p>25, Min kursivering. Alex Schulman, <em>Bränn alla mina</em> <em>brev</em>, s. 50–51. Att årtalet 1932 (eller ”sommaren 1932” återkommer i Stolpes skrifter är något som Schulman upprepar i åtskilliga intervjuer: <a href="https://www.aftonbladet.se/nojesbladet/a/kaj9GA/alex-schulman-om-familjehemligheten-en-otrolig-historia">https://www.aftonbladet.se/nojesbladet/a/kaj9GA/alex-schulman-om-familjehemligheten-en-otrolig-historia</a>; <a href="https://www.expressen.se/kultur/film--tv/det-borjade-med-ett-brak-i-natten/">https://www.expressen.se/kultur/film&#8211;tv/det-borjade-med-ett-brak-i-natten/</a>; <a href="https://sverigesradio.se/play/avsnitt/1195241">https://sverigesradio.se/play/avsnitt/1195241</a> 53:00; <a href="https://www.hemtrevligt.se/hemmetsjournal/artiklar/artiklar/20181216/antligen-forstar-jag-upphovet-till-min-ilska/">https://www.hemtrevligt.se/hemmetsjournal/artiklar/artiklar/20181216/antligen-forstar-jag-upphovet-till-min-ilska/</a>; <a href="https://sverigesradio.se/play/avsnitt/1188007">https://sverigesradio.se/play/avsnitt/1188007</a> 30:20; <a href="https://sverigesradio.se/play/avsnitt/1182959">https://sverigesradio.se/play/avsnitt/1182959</a>; <a href="https://www.sydsvenskan.se/2018-11-06/alex-schulman-han-ar-urondskan">https://www.sydsvenskan.se/2018-11-06/alex-schulman-han-ar-urondskan</a>; <a href="https://www.hbl.fi/artikel/5db33f2d-a1f2-4cd9-8a70-52a07c108e28">https://www.hbl.fi/artikel/5db33f2d-a1f2-4cd9-8a70-52a07c108e28</a>; <a href="https://www.svtplay.se/video/e55Bb6e/babel/maria-aljochina-alex-schulman-och-loreen">https://www.svtplay.se/video/e55Bb6e/babel/maria-aljochina-alex-schulman-och-loreen</a> 6:15;  <a href="https://www.youtube.com/watch?v=iggK8LlXbak">https://www.youtube.com/watch?v=iggK8LlXbak</a> (denna gång är katastrofen 1932 något som Stolpe återvänder till ”i varje bok”).</p>
<p>26, Däremot märker jag att Schulman tenderar att slarva med referenser till citat om Stolpes livskris. De första två citaten som anförs i <em>Bränn alla mina brev</em> (sid 51) påstås vara hämtade från den första respektive andra av Stolpes memoarböcker, men står i själva verket i samma bok på samma uppslag, se: <em>Stormens år </em>(Askild och Kärnekull, 1975), s. 14–15; Alex Schulman, <em>Bränn alla mina brev</em>, s. 51–52. Nästa citat (sid 52) ska stå ”längre fram” i samma bok, men finns istället i en helt annan bok (som dessutom är på tyska), nämligen <em>Ich blicke zurück – ich blicke voraus</em> (Josef Knecht 1965), 11–13. Översättningen som Schulman använder är hämtad från Svante Nordin, <em>Sven Stolpe</em>, s. 125–126).</p>
<p>27, <a href="https://www.hemtrevligt.se/hemmetsjournal/artiklar/artiklar/20181216/antligen-forstar-jag-upphovet-till-min-ilska/">https://www.hemtrevligt.se/hemmetsjournal/artiklar/artiklar/20181216/antligen-forstar-jag-upphovet-till-min-ilska/</a></p>
<p>28, Alex Schulman, <em>Bränn alla mina brev,</em> s. 54. Schulman upprepar detta ofta i intervjuer: <a href="https://www.expressen.se/noje/otrohetsaffaren-som-ligger-bakom-schulmans-vrede/#:~:text=Alex%20Schulman%20ville%20hitta%20orsaken,boken%20om%20den%20m%C3%B6rka%20familjehemligheten">https://www.expressen.se/noje/otrohetsaffaren-som-ligger-bakom-schulmans-vrede/#:~:text=Alex%20Schulman%20ville%20hitta%20orsaken,boken%20om%20den%20m%C3%B6rka%20familjehemligheten</a>; <a href="https://www.svtplay.se/video/e55Bb6e/babel/maria-aljochina-alex-schulman-och-loreen">https://www.svtplay.se/video/e55Bb6e/babel/maria-aljochina-alex-schulman-och-loreen</a> 5:00; <a href="https://sverigesradio.se/play/avsnitt/1195241">https://sverigesradio.se/play/avsnitt/1195241</a> 53:30; <a href="https://www.hemtrevligt.se/hemmetsjournal/artiklar/artiklar/20181216/antligen-forstar-jag-upphovet-till-min-ilska/">https://www.hemtrevligt.se/hemmetsjournal/artiklar/artiklar/20181216/antligen-forstar-jag-upphovet-till-min-ilska/</a>; <a href="https://sverigesradio.se/play/avsnitt/1188007">https://sverigesradio.se/play/avsnitt/1188007</a> 30:20; <a href="https://sverigesradio.se/play/avsnitt/1182959">https://sverigesradio.se/play/avsnitt/1182959</a>; <a href="https://www.sydsvenskan.se/2018-11-06/alex-schulman-han-ar-urondskan">https://www.sydsvenskan.se/2018-11-06/alex-schulman-han-ar-urondskan</a>; <a href="https://www.hbl.fi/artikel/5db33f2d-a1f2-4cd9-8a70-52a07c108e28">https://www.hbl.fi/artikel/5db33f2d-a1f2-4cd9-8a70-52a07c108e28</a>; <a href="https://www.youtube.com/watch?v=iggK8LlXbak">https://www.youtube.com/watch?v=iggK8LlXbak</a>.</p>
<p>29, <a href="https://www.dn.se/kultur/triangeldramat-brann-alla-mina-brev-saknar-passionen/">https://www.dn.se/kultur/triangeldramat-brann-alla-mina-brev-saknar-passionen/</a></p>
<p>30,Denna falsifiering har lyckats smyga in i media här och där. Bland annat: <em>Dagens Nyheter</em> (<a href="https://www.dn.se/kultur/triangeldramat-brann-alla-mina-brev-saknar-passionen/">https://www.dn.se/kultur/triangeldramat-brann-alla-mina-brev-saknar-passionen/</a>), <em>Babel</em> i <em>SVT </em>(<a href="https://www.facebook.com/watch/?v=782028595467415">https://www.facebook.com/watch/?v=782028595467415</a>) <em>Expressen</em> (<a href="https://www.expressen.se/kultur/bocker/pa-jakt-efter-familjens-giftiga-vrede/">https://www.expressen.se/kultur/bocker/pa-jakt-efter-familjens-giftiga-vrede/</a> samt <a href="https://www.expressen.se/nyheter/otrohetsdrama-i-kultureliten-karlek-hat-och-mordforsok/">https://www.expressen.se/nyheter/otrohetsdrama-i-kultureliten-karlek-hat-och-mordforsok/</a> och <a href="https://www.expressen.se/kultur/film--tv/det-borjade-med-ett-brak-i-natten/">https://www.expressen.se/kultur/film&#8211;tv/det-borjade-med-ett-brak-i-natten/</a>), <em>Kulturnytt i P4 </em>(<a href="https://sverigesradio.se/artikel/7090511">https://sverigesradio.se/artikel/7090511</a>), <em>Lundströms bokradio </em>i Sveriges Radio (<a href="https://sverigesradio.se/play/avsnitt/1188007">https://sverigesradio.se/play/avsnitt/1188007</a>, där man får läsa att Sven Stolpe ”livet igenom” refererade till ett ”sexuellt attentat” som han utsattes för, <em>Göteborgsposten </em>(<a href="https://www.gp.se/kultur/alex-schulman-skriver-vackert-och-sorgligt-om-mormoderns-otrohet-1.11098990">https://www.gp.se/kultur/alex-schulman-skriver-vackert-och-sorgligt-om-mormoderns-otrohet-1.11098990</a>), <em>Hufvudstadsbladet</em> (<a href="https://www.hbl.fi/artikel/5db33f2d-a1f2-4cd9-8a70-52a07c108e28">https://www.hbl.fi/artikel/5db33f2d-a1f2-4cd9-8a70-52a07c108e28</a>), <em>Sydsvenskan </em>(<a href="https://www.sydsvenskan.se/2018-11-24/alex-schulman-skildrar-lyhort-sin-jakt-pa-familjens-svarta">https://www.sydsvenskan.se/2018-11-24/alex-schulman-skildrar-lyhort-sin-jakt-pa-familjens-svarta</a> samt <a href="https://www.sydsvenskan.se/2018-11-06/alex-schulman-han-ar-urondskan">https://www.sydsvenskan.se/2018-11-06/alex-schulman-han-ar-urondskan</a>), <em>Uppsala Nya Tidning </em>(<a href="https://unt.se/kultur/film/artikel/har-utspelade-sig-verklighetens-brann-alla-mina-brev-schulman-har-besokt-stiftelsen-manga-ganger/l65znzvr">https://unt.se/kultur/film/artikel/har-utspelade-sig-verklighetens-brann-alla-mina-brev-schulman-har-besokt-stiftelsen-manga-ganger/l65znzvr</a>), <em>Hemtrevligt </em>(<a href="https://www.hemtrevligt.se/hemmetsjournal/artiklar/artiklar/20181216/antligen-forstar-jag-upphovet-till-min-ilska/">https://www.hemtrevligt.se/hemmetsjournal/artiklar/artiklar/20181216/antligen-forstar-jag-upphovet-till-min-ilska/</a>), <em>Morgonpasset i P3</em> (<a href="https://sverigesradio.se/avsnitt/1195241">https://sverigesradio.se/avsnitt/1195241</a>), <em>Opulens</em> (<a href="https://www.opulens.se/litteratur/uppriktigt-om-nedarvd-vrede/">https://www.opulens.se/litteratur/uppriktigt-om-nedarvd-vrede/</a>), <em>Sektpodden </em>(<a href="https://open.spotify.com/episode/02feeH5YKGW9MTwfR7qd5h?si=GSxqsEzdT3eP2sd2yWtOPw&amp;nd=1">https://open.spotify.com/episode/02feeH5YKGW9MTwfR7qd5h?si=GSxqsEzdT3eP2sd2yWtOPw&amp;nd=1</a>),</p>
<p>samt av <em>Gefle dagblad </em>(<a href="https://www.gd.se/2022-09-21/filmkollen-enastaende-filmatisering-av-schulman-roman">https://www.gd.se/2022-09-21/filmkollen-enastaende-filmatisering-av-schulman-roman</a>).</p>
<p>31, <a href="https://www.hbl.fi/artikel/5db33f2d-a1f2-4cd9-8a70-52a07c108e28">https://www.hbl.fi/artikel/5db33f2d-a1f2-4cd9-8a70-52a07c108e28</a></p>
<p>32, Sven Stolpe, <em>Idyll och orosmoln</em>, Askild och Kärnekull 1974, s. 280. Se avsnittet ”Om ett sexuellt attentat” på <a href="http://www.svenstolpe.se">www.svenstolpe.se</a>.</p>
<p>33, Källan till ett sammankopplande  av ”katastrofen” med sommaren 1932 kommer från Svante Nordin, <em>Sven Stolpe</em>, s. 125, men det blir inte sant för det. Inga brev från 1932 eller 1933 vittnar om att Stolpe ens skulle ha känt till affären med Lagercrantz. Krisen verkar snarare inträffa kring 1936, och då med en annan man än Lagercrantz inblandad. Detta framgår i Stolpes brev till Kaj Bonnier från 1936 som förvaras på Bonniers arkiv. Se även Stolpes brev till litteraturkritikern Holger Ahlenius från samma år på Uppsala universitetsbibliotek. I ett brev till översättaren Lennart Göthberg från 1945 anger Stolpe 1936 som året då händelsen inträffade som gjorde att han hamnade i ett ”andligt träsk”.</p>
<p>34, Detta gör det tveksamt att Sven Stolpe skulle ha ”kommit på” Olof och Karin, som Alex Schulman påstår. Mig veterligen finns inga explicita referenser till affären med Lagercrantz i Stolpes anteckningar eller brevväxling någon gång under hela hans liv. Alex Schulman verkar mena att Stolpes avsky för Lagercrantz beror på att han hade upptäckt otrohetsaffären och ältade minnet. Visserligen är det ingen hemlighet att Sven Stolpe, som han själv skrev, ”avskyr av hjärtat Olof Lagercrantz’ hela agitation” (Sven Stolpe, <em>Låt mig berätta</em>, Askild &amp; Kärnekull 1971, s. 136). Men detta patos kan också bero på andra faktorer, vilket Stolpe själv menade. Dels ideologiska: ”Olof Lagercrantz representerar allt det som jag [Sven Stolpe] är emot: hans kristendomshat, hans förlöjligande av Kristus och allting sådant&#8230;” (<a href="https://www.svtplay.se/video/8DYEqxe/gast-hos-hagge/4-sven-stolpe?id=8DYEqxe">https://www.svtplay.se/video/8DYEqxe/gast-hos-hagge/4-sven-stolpe?id=8DYEqxe</a> 4:10). Dels menade Stolpe att hans avsky berodde på ”förföljelsen han [Olof Lagercrantz] i decennier ägnat mig” på Dagens Nyheter (<em>Låt mig berätta</em>, s. 136). Dels var Stolpe upprörd över kulturprofilens allmänna i hans ögon omoraliska beteende (se i synnerhet Stolpes brev till Stig Allsing 11 oktober 1974).</p>
<p>Om den ideologiska delen av konflikten se även sektionen ”Sven och Olof: Ett livslångt hat?” på <a href="http://www.svenstolpe.se">www.svenstolpe.se</a>. Sven Stolpes brev till Olof Lagercrantz där han beklagar Olofs olyckliga kärlek till Karin kan tolkas som att Sven insett att Olof var kär i hans hustru (Bränn alla mina brev, s. 257) men inget i brevet tyder på att Sven uppfattade det som att Olof och Karin hade haft en sexuell relation.</p>
<p>35, <a href="https://sverigesradio.se/play/avsnitt/1195241">https://sverigesradio.se/play/avsnitt/1195241</a> 53:30.</p>
<p>36, I boken skickar Schulman ett meddelande till biblioteket: ”Jag fick veta att jag inte kunde beställa fram hela Sven Stolpes arkiv, men det är alltså det jag ändå ber om. Ta upp alltihop. Så slipper ni springa i korridorerna” (Alex Schulman, <em>Bränn alla mina brev</em>, s. 80). Jag har letat efter detta meddelande i registraturen – det är nämligen en allmän handling – men hittar inget spår av det.</p>
<p>37,  <a href="https://www.dn.se/kultur-noje/varfor-rasar-alex-schulman/">https://www.dn.se/kultur-noje/varfor-rasar-alex-schulman/</a></p>
<p>38, Alex Schulman, <em>Bränn alla mina brev</em>, s. 80.</p>
<p>39, Alex Schulman, <em>Bränn alla mina brev</em>, s. 80. Brev <em>till</em> Astrid Lindgren nämns också av Schulman i intervjuer: <a href="https://sverigesradio.se/play/avsnitt/1195241">https://sverigesradio.se/play/avsnitt/1195241</a> Breven <em>från</em> Astrid Lindgren och Ingmar Bergman diskuteras av Svante Nordin, <em>Sven Stolpe</em>, s. 278. Nordin beskriver brevväxlingen med Bergman som ”vänskaplig”. Men Schulman säger till <em>Ålands radio</em>om att han har läst brev från Stolpe till Ingmar Bergman ( som inte finns i arkivet) där morfadern ”är arg på Ingmar Bergman”. <a href="https://alandsradio.ax/lyssna?nid=166662&amp;fid=139854">https://alandsradio.ax/lyssna?nid=166662&amp;fid=139854</a> 07:00..</p>
<p>40, Arga brev till Gunnar Sträng nämns också i intervjuer: <a href="https://alandsradio.ax/lyssna?nid=166662&amp;fid=139854">https://alandsradio.ax/lyssna?nid=166662&amp;fid=139854</a> 53:45.</p>
<p>41, Alex Schulman berättar i SVT:s program Babel att han har läst alla dessa brev i Sven Stolpes arkiv i Uppsala: ”Jag läser brev till Palme, till Ingmar Bergman, Astrid Lindgren, han [Sven Stolpe] bråkar med Gunnar Sträng och han är jättearg på Eyvind Johnson.” (<a href="https://www.svtplay.se/video/e55Bb6e/babel/maria-aljochina-alex-schulman-och-loreen">https://www.svtplay.se/video/e55Bb6e/babel/maria-aljochina-alex-schulman-och-loreen</a> 6:50-7:04).</p>
<p>42, <a href="https://www.svtplay.se/video/j4zo5RY/min-sanning/alex-schulman?position=358&amp;id=j4zo5RY">https://www.svtplay.se/video/j4zo5RY/min-sanning/alex-schulman?position=358&amp;id=j4zo5RY</a> 6:00.</p>
<p>43, <a href="https://www.hbl.fi/artikel/5db33f2d-a1f2-4cd9-8a70-52a07c108e28">https://www.hbl.fi/artikel/5db33f2d-a1f2-4cd9-8a70-52a07c108e28</a>. Alex Schulman berättar historien om OL-initialerna i minst 10 intervjuer: <a href="https://sverigesradio.se/play/avsnitt/1188007">https://sverigesradio.se/play/avsnitt/1188007</a> 31:00; <a href="https://www.dn.se/kultur-noje/varfor-rasar-alex-schulman/">https://www.dn.se/kultur-noje/varfor-rasar-alex-schulman/</a>; <a href="https://www.expressen.se/noje/schulman-skriver-bok-om-sin-mormors-karleksaffar-med-olof-lagercrantz/">https://www.expressen.se/noje/schulman-skriver-bok-om-sin-mormors-karleksaffar-med-olof-lagercrantz/</a>; <a href="https://www.expressen.se/kultur/film--tv/det-borjade-med-ett-brak-i-natten/">https://www.expressen.se/kultur/film&#8211;tv/det-borjade-med-ett-brak-i-natten/</a>;   <a href="https://www.hemtrevligt.se/hemmetsjournal/artiklar/artiklar/20181216/antligen-forstar-jag-upphovet-till-min-ilska/">https://www.hemtrevligt.se/hemmetsjournal/artiklar/artiklar/20181216/antligen-forstar-jag-upphovet-till-min-ilska/</a>; <a href="https://www.youtube.com/watch?v=ZbIwFkaOpc8">https://www.youtube.com/watch?v=ZbIwFkaOpc8</a>; <a href="https://sverigesradio.se/play/avsnitt/1188007">https://sverigesradio.se/play/avsnitt/1188007</a>; <a href="https://sverigesradio.se/play/avsnitt/1182959">https://sverigesradio.se/play/avsnitt/1182959</a> 21:55; <a href="https://www.aftonbladet.se/nojesbladet/a/kaj9GA/alex-schulman-om-familjehemligheten-en-otrolig-historia">https://www.aftonbladet.se/nojesbladet/a/kaj9GA/alex-schulman-om-familjehemligheten-en-otrolig-historia</a>; <a href="https://www.hbl.fi/artikel/5db33f2d-a1f2-4cd9-8a70-52a07c108e28">https://www.hbl.fi/artikel/5db33f2d-a1f2-4cd9-8a70-52a07c108e28</a>; <a href="https://alandsradio.ax/lyssna?nid=166662&amp;fid=139854">https://alandsradio.ax/lyssna?nid=166662&amp;fid=139854</a>.</p>
<p>44, <a href="https://sverigesradio.se/play/avsnitt/1195241">https://sverigesradio.se/play/avsnitt/1195241</a> 54:00. Schulman brukar citera detta, ständigt i nya tappningar, t.ex. i <em>Expressen TV</em>: ”Träffade OL på Stallmästargården med sedvanligt resultat: illamående, yrsel, förtvivlans bön” (<a href="https://www.youtube.com/watch?v=ZbIwFkaOpc8">https://www.youtube.com/watch?v=ZbIwFkaOpc8</a>) alternativt i <em>Dagens Nyheter</em>: ”Mötte OL på Stallmästargården, med sedvanligt resultat. Illamående, kräkningar, förtvivlans bön” (<a href="https://www.dn.se/kultur-noje/varfor-rasar-alex-schulman/">https://www.dn.se/kultur-noje/varfor-rasar-alex-schulman/</a>; se även <a href="https://alandsradio.ax/lyssna?nid=166662&amp;fid=139854">https://alandsradio.ax/lyssna?nid=166662&amp;fid=139854</a>). En gång citerar Schulman på samma sätt som det står i boken (<a href="https://www.hemtrevligt.se/hemmetsjournal/artiklar/artiklar/20181216/antligen-forstar-jag-upphovet-till-min-ilska/">https://www.hemtrevligt.se/hemmetsjournal/artiklar/artiklar/20181216/antligen-forstar-jag-upphovet-till-min-ilska/</a>).</p>
<p>45, Alex Schulman, <em>Bränn alla mina brev,</em> s. 83.</p>
<p>46, <a href="https://www.sydsvenskan.se/2018-11-06/alex-schulman-han-ar-urondskan">https://www.sydsvenskan.se/2018-11-06/alex-schulman-han-ar-urondskan</a>; <a href="https://www.hbl.fi/artikel/5db33f2d-a1f2-4cd9-8a70-52a07c108e28">https://www.hbl.fi/artikel/5db33f2d-a1f2-4cd9-8a70-52a07c108e28</a>.</p>
<p>47, Alex Schulman, <em>Bränn alla mina brev,</em> s. 83. Samt i en intervju med <em>Hemtrevligt</em>: <a href="https://www.hemtrevligt.se/hemmetsjournal/artiklar/artiklar/20181216/antligen-forstar-jag-upphovet-till-min-ilska/">https://www.hemtrevligt.se/hemmetsjournal/artiklar/artiklar/20181216/antligen-forstar-jag-upphovet-till-min-ilska/</a></p>
<p>48, Se avsnittet ”Sven och Olof: Ett livslång hat” på <a href="http://www.svenstolpe.se">www.svenstolpe.se</a>.</p>
<p>49, Alex Schulman, <em>Bränn alla mina brev</em>, s. 83. ”Brevet” citeras som en pålitlig källa av Therese Eriksson i <em>Expressen</em>: ”Inga demoner har visat sig – jag har inte tänkt på OL på hela dagen!” <a href="https://www.expressen.se/kultur/bocker/pa-jakt-efter-familjens-giftiga-vrede/">https://www.expressen.se/kultur/bocker/pa-jakt-efter-familjens-giftiga-vrede/</a></p>
<p>50, Det finns över huvud taget inga brev från Sven till Karin år 1952 i Stolpe-arkivet. Formuleringen som Schulman anger finns inte heller i någon av de andra arkiverade breven från Sven till Karin.</p>
<p>51, Alex Schulman, <em>Bränn alla mina brev</em>, s. 83. ”Detta livet, ett evigt mörker. [&#8230;] när jag ser en ljusning kommer OL tillbaka, i mina tankar och mina drömmar.”</p>
<p>52, <a href="https://sverigesradio.se/play/avsnitt/1188007">https://sverigesradio.se/play/avsnitt/1188007</a> 31:00 och framåt.</p>
<p>53, <a href="https://sverigesradio.se/play/avsnitt/1182959">https://sverigesradio.se/play/avsnitt/1182959</a> 21:30.</p>
<p>54, <a href="https://sverigesradio.se/play/avsnitt/1195241">https://sverigesradio.se/play/avsnitt/1195241</a>.</p>
<p>55, ”Skräckdrömmar” i almanackorna nämns i Sven Stolpe, <em>Stormens år</em>, s. 14. Men det står inte att de skulle vara kopplade till någon OL.</p>
<p>56, De enda ”OL” jag lyckats finna är: 1) från ett brev från Lisette Schulman till Sven Stolpe från 1962, som Stolpe har skrivit på och sänt vidare till Karin Stolpe. Brevet börjar med att Stolpe skriver att Lisette ”måste hem ett litet tag. Hon är min bästa vän.” (Det i sin tur skär sig med Schulmans påstående att Stolpe inte ville ha med Lisette att göra, som han hävdar i <em>Glöm mig</em>, s. 180–181, Bookmark 201 .) Stolpe säger att de negativa recensionerna han får av OL och Ivar Harrie ”berör mig inte i det ringaste”. 2) från ett romanutkast där Stolpe skriver om att göra en karaktär som ”OL. Med sinnessjuk son som alltså vill mörda honom.”</p>
<p>57,<a href="https://www.dn.se/kultur-noje/bokrecensioner/bokrecension-brann-alla-mina-brev-av-alex-schulman/"> https://www.dn.se/kultur-noje/bokrecensioner/bokrecension-brann-alla-mina-brev-av-alex-schulman/</a></p>
<p>58, <a href="https://www.expressen.se/noje/otrohetsaffaren-som-ligger-bakom-schulmans-vrede/#:~:text=Alex%20Schulman%20ville%20hitta%20orsaken,boken%20om%20den%20m%C3%B6rka%20familjehemligheten">https://www.expressen.se/noje/otrohetsaffaren-som-ligger-bakom-schulmans-vrede/#:~:text=Alex%20Schulman%20ville%20hitta%20orsaken,boken%20om%20den%20m%C3%B6rka%20familjehemligheten</a>;  Programledaren SVT:s <em>Babel </em>säger: ”Alex Schulman är här för att avslöja sina familjehemligheter” <a href="https://www.svtplay.se/video/e55Bb6e/babel/maria-aljochina-alex-schulman-och-loreen">https://www.svtplay.se/video/e55Bb6e/babel/maria-aljochina-alex-schulman-och-loreen</a> 1:15).</p>
<p>59, <a href="https://www.expressen.se/nyheter/otrohetsdrama-i-kultureliten-karlek-hat-och-mordforsok/">https://www.expressen.se/nyheter/otrohetsdrama-i-kultureliten-karlek-hat-och-mordforsok/</a></p>
<p>60, Enligt Jens Liljestrand: <a href="https://www.youtube.com/watch?v=ZbIwFkaOpc8">https://www.youtube.com/watch?v=ZbIwFkaOpc8</a>.</p>
<p>61, Temat har först behandlats i tryck i Stina Otterberg,<em> Klädd i sitt språk: Kritikern Olof Lagercrantz</em> (Ellerströms 2010), s. 147–148, 151–152.</p>
<p>62, Alex Schulman, <em>Bränn alla mina brev</em>, s. 7. Se även: <a href="https://vi.se/artikel/srdEDo6W-a0j2LRwp-61f99">https://vi.se/artikel/srdEDo6W-a0j2LRwp-61f99</a>.</p>
<p>63, <a href="https://sverigesradio.se/play/avsnitt/1188007">https://sverigesradio.se/play/avsnitt/1188007</a> 35:00; jmf. <a href="https://alandsradio.ax/lyssna?nid=166662&amp;fid=139854">https://alandsradio.ax/lyssna?nid=166662&amp;fid=139854</a>.</p>
<p>64, Alex Schulman, <em>Bränn alla mina brev</em>, s. 7.</p>
<p>65, <a href="https://podcasts.apple.com/se/podcast/355-these-strange-things-happen-all-the-time/id534137041?i=1000431835667">https://podcasts.apple.com/se/podcast/355-these-strange-things-happen-all-the-time/id534137041?i=1000431835667</a> 1:23:00.</p>
<p>66, Alex Schulman, <em>Glöm mig</em>, s. 182.</p>
<p>67, Svante Nordin, <em>Sven Stolpe</em>, s. 247; Alex Schulman, <em>Bränn alla mina brev</em> (Bookmark, 2018): ”Sven Stolpe tog jobb på Mjölby universitet 1967.”</p>
<p>68, <a href="https://www.svtplay.se/video/j4zo5RY/min-sanning/alex-schulman?position=783&amp;id=j4zo5RY">https://www.svtplay.se/video/j4zo5RY/min-sanning/alex-schulman?position=783&amp;id=j4zo5RY</a> 13:00; Alex Schulman, <em>Bränn alla mina brev</em>, s. 122: ”Bosses föräldrar var bönder”. Något som inte heller stämmer.</p>
<p>69, Alex Schulman, <em>Glöm mig</em>, s. 182.</p>
<p>70, <a href="https://www.expressen.se/halsoliv/manskligt/alex-schulman-jag-bar-inte-pa-en-vrede">https://www.expressen.se/halsoliv/manskligt/alex-schulman-jag-bar-inte-pa-en-vrede</a>. Det överensstämmer med versionen i <em>Glöm mig</em>, s. 182: ”Hon berättade sedan historien för Calle, helt apropå ingenting, under en middag.”</p>
<p>71, <a href="https://www.svtplay.se/video/j4zo5RY/min-sanning/alex-schulman?position=783&amp;id=j4zo5RY">https://www.svtplay.se/video/j4zo5RY/min-sanning/alex-schulman?position=783&amp;id=j4zo5RY</a> 14:00.</p>
<p>72, <a href="https://podcasts.nu/avsnitt/alex-och-sigges-podcast/564-slaget-om-sjalen-I5cxomN0N">https://podcasts.nu/avsnitt/alex-och-sigges-podcast/564-slaget-om-sjalen-I5cxomN0N</a></p>
<p>73, Alex Schulman, <em>Glöm mig</em>, s. 182-183.</p>
<p>74, <a href="https://www.svtplay.se/video/j4zo5RY/min-sanning/alex-schulman?position=894&amp;id=j4zo5RY">https://www.svtplay.se/video/j4zo5RY/min-sanning/alex-schulman?position=894&amp;id=j4zo5RY</a> 15:15.</p>
<p>75, Enligt en variant hänger det första dagen en lapp på anslagstavlan, dagen efter hänger samma lapp där igen. ”Dag nummer tre så är det lappar överallt.” (<a href="https://www.svtplay.se/video/j4zo5RY/min-sanning/alex-schulman?position=874&amp;id=j4zo5RY">https://www.svtplay.se/video/j4zo5RY/min-sanning/alex-schulman?position=874&amp;id=j4zo5RY</a> 14:15). Eller, enligt en kortare version: första dagen hängs en lapp upp, dagen därpå är det lappar överallt (<a href="https://svenska.yle.fi/a/7-1240470">https://svenska.yle.fi/a/7-1240470</a>). Eller så är det bara en enda lapp på anslagstavlan, tre dagar i rad (Alex Schulman, Bränn alla mina brev, s. 122) – eller  ”kanske till och med en fjärde lapp dag fyra” (<a href="https://podcasts.nu/avsnitt/alex-och-sigges-podcast/564-slaget-om-sjalen-I5cxomN0N">https://podcasts.nu/avsnitt/alex-och-sigges-podcast/564-slaget-om-sjalen-I5cxomN0N</a>).</p>
<p>76, <a href="https://podcasts.nu/avsnitt/alex-och-sigges-podcast/564-slaget-om-sjalen-I5cxomN0N">https://podcasts.nu/avsnitt/alex-och-sigges-podcast/564-slaget-om-sjalen-I5cxomN0N</a></p>
<p>77, <a href="https://podcasts.nu/avsnitt/alex-och-sigges-podcast/564-slaget-om-sjalen-I5cxomN0N">https://podcasts.nu/avsnitt/alex-och-sigges-podcast/564-slaget-om-sjalen-I5cxomN0N</a></p>
<p>78, <a href="https://www.dn.se/kultur-noje/varfor-rasar-alex-schulman/">https://www.dn.se/kultur-noje/varfor-rasar-alex-schulman/</a>. Bland andra medier som godtar Schulmans tunga anklagelser som sanna återfinns <em>Expressen</em>: ”Schulman upptäcker att Sven Stolpe försökte skada både sig själv och Karin när kärleksaffären avslöjades.” (<a href="https://www.expressen.se/noje/otrohetsaffaren-som-ligger-bakom-schulmans-vrede/">https://www.expressen.se/noje/otrohetsaffaren-som-ligger-bakom-schulmans-vrede/</a>); <a href="https://www.expressen.se/nyheter/otrohetsdrama-i-kultureliten-karlek-hat-och-mordforsok/">https://www.expressen.se/nyheter/otrohetsdrama-i-kultureliten-karlek-hat-och-mordforsok/</a>.</p>
<p>79, <a href="https://sverigesradio.se/play/avsnitt/1195241">https://sverigesradio.se/play/avsnitt/1195241</a> 53:30. Liksom i <em>P4</em>: ”Morfar kommer på dem. Han var brutal, en ganska läskig typ faktiskt. Det är förenat med livsfara, om det skulle komma ut. Om han skulle få nys om det, vilket han då får. Då blir hon så skrämd av det han gör, för att han blir brutal. Han försöker faktiskt ta livet av henne” (<a href="https://sverigesradio.se/play/avsnitt/1182959">https://sverigesradio.se/play/avsnitt/1182959</a> 24:50 och framåt).</p>
<p>80, Alex Schulman, <em>Bränn alla mina brev</em>, s. 254-255.</p>
<p>81, <a href="https://www.expressen.se/nyheter/otrohetsdrama-i-kultureliten-karlek-hat-och-mordforsok/">https://www.expressen.se/nyheter/otrohetsdrama-i-kultureliten-karlek-hat-och-mordforsok/</a>; ”Schulman upptäcker att Sven Stolpe försökte skada både sig själv och Karin när kärleksaffären avslöjades.” (<a href="https://www.expressen.se/noje/otrohetsaffaren-som-ligger-bakom-schulmans-vrede/#:~:text=Alex%20Schulman%20ville%20hitta%20orsaken,boken%20om%20den%20m%C3%B6rka%20familjehemligheten">https://www.expressen.se/noje/otrohetsaffaren-som-ligger-bakom-schulmans-vrede/#:~:text=Alex%20Schulman%20ville%20hitta%20orsaken,boken%20om%20den%20m%C3%B6rka%20familjehemligheten</a>); <a href="https://www.svtplay.se/video/e55Bb6e/babel/maria-aljochina-alex-schulman-och-loreen">https://www.svtplay.se/video/e55Bb6e/babel/maria-aljochina-alex-schulman-och-loreen</a> 11:10: ”Sven Stolpe upptäcker dem [Karin och Olof] och det blir brutalt och ganska hemskt.”</p>
<p>82, Alex Schulman, <em>Bränn alla mina brev</em>, s. 43.</p>
<p>83, <a href="https://arkivet.dn.se/sok?q=stolpe%20diket&amp;from=1931-05-26&amp;sort=newest&amp;to=1931-05-26">https://arkivet.dn.se/sok?q=stolpe%20diket&amp;from=1931-05-26&amp;sort=newest&amp;to=1931-05-26</a></p>
<p>84, Svante Nordin, <em>Sven Stolpe</em>, s. 174. Se även avsnittet ”Om mordförsök på Karin Stolpe” på <a href="http://www.svenstolpe.se">www.svenstolpe.se</a></p>
<p>85, <a href="https://m.facebook.com/story.php?story_fbid=pfbid0DBAkSS1sGnRpzvEs7SRT6d2ZHxHDVbmzey6ycbTHgpuCoK1ka9L2tUmUhv2WWpdhl&amp;id=100000178486689">https://m.facebook.com/story.php?story_fbid=pfbid0DBAkSS1sGnRpzvEs7SRT6d2ZHxHDVbmzey6ycbTHgpuCoK1ka9L2tUmUhv2WWpdhl&amp;id=100000178486689</a></p>
<p>86, <a href="https://ljsp.lwcdn.com/api/video/embed.jsp?id=c652afa3-8f0e-4917-be57-2fddcf66fb58">https://ljsp.lwcdn.com/api/video/embed.jsp?id=c652afa3-8f0e-4917-be57-2fddcf66fb58</a> 10:15 och framåt.</p>
<p>87, <a href="https://www.cafe.se/alex-schulman-omslagsintervju/">https://www.cafe.se/alex-schulman-omslagsintervju/</a>; <a href="https://podcasts.nu/avsnitt/alex-och-sigges-podcast/564-slaget-om-sjalen-I5cxomN0N">https://podcasts.nu/avsnitt/alex-och-sigges-podcast/564-slaget-om-sjalen-I5cxomN0N</a>; <a href="https://ljsp.lwcdn.com/api/video/embed.jsp?id=c652afa3-8f0e-4917-be57-2fddcf66fb58">https://ljsp.lwcdn.com/api/video/embed.jsp?id=c652afa3-8f0e-4917-be57-2fddcf66fb58</a> 10:15 och framåt.</p>
<p>88, ”<em>Sandheden er jo, at affæren slutter med et mordforsøg. Og da mordforsøget mislykkedes, så tager Sven livet af Karin på en anden måde – bare langsommere og gennem flere årtier”</em> <a href="https://bog.dk/alex-schulman-om-romanen-braend-alle-mine-breve/">https://bog.dk/alex-schulman-om-romanen-braend-alle-mine-breve/</a>;  ”<em>Mein Großvater hat offensichtlich versucht, meine Großmutter umzubringen, als er von der Affäre erfuhr.” </em><a href="https://www.buchkultur.net/alex-schulman-2/">https://www.buchkultur.net/alex-schulman-2/</a></p>
<p>89, <a href="https://ljsp.lwcdn.com/api/video/embed.jsp?id=c652afa3-8f0e-4917-be57-2fddcf66fb58">https://ljsp.lwcdn.com/api/video/embed.jsp?id=c652afa3-8f0e-4917-be57-2fddcf66fb58</a> 10:15;  <a href="https://buechermenschen.de/interview/exklusiv-interview-mit-alex-schulman/">https://buechermenschen.de/interview/exklusiv-interview-mit-alex-schulman/</a></p>
<p>90, <a href="https://podcasts.nu/avsnitt/alex-och-sigges-podcast/564-slaget-om-sjalen-I5cxomN0N">https://podcasts.nu/avsnitt/alex-och-sigges-podcast/564-slaget-om-sjalen-I5cxomN0N</a></p>
<p>91, Schulman själv citerar detta i <em>Bränn alla mina brev</em>, s. 256, men ersätter ”körde i diket” med ”körde av vägen”.</p>
<p>92, Richard Lagercrantz säger till Alex Schulman: ”Jag har kärleksbreven mellan Karin Stolpe och Olof från sommaren 1932” (<a href="https://www.aftonbladet.se/nojesbladet/a/kaj9GA/alex-schulman-om-familjehemligheten-en-otrolig-historia">https://www.aftonbladet.se/nojesbladet/a/kaj9GA/alex-schulman-om-familjehemligheten-en-otrolig-historia</a>). Det finns dessutom ett antal olika berättelser om hur Alex Schulman fick tag på dessa brev (något som även uppmärksammats i <em>Söndagsintervjun</em> <a href="https://sverigesradio.se/avsnitt/alex-schulman-jagar-den-perfekta-historien">https://sverigesradio.se/avsnitt/alex-schulman-jagar-den-perfekta-historien</a>). I vissa fall börjar det med ett telefonsamtal (<a href="https://www.aftonbladet.se/nojesbladet/a/kaj9GA/alex-schulman-om-familjehemligheten-en-otrolig-historia">https://www.aftonbladet.se/nojesbladet/a/kaj9GA/alex-schulman-om-familjehemligheten-en-otrolig-historia</a>), i andra, ett mail (<a href="https://www.youtube.com/watch?v=iggK8LlXbak">https://www.youtube.com/watch?v=iggK8LlXbak</a>), i andra fall medlas kontakten av David Lagercrantz.Någon gång tas Richards roll över av David Lagercrantz i berättelsen (<a href="https://m.youtube.com/watch?v=8ggRJEP54NM&amp;feature=youtu.be">https://m.youtube.com/watch?v=8ggRJEP54NM&amp;feature=youtu.be</a>).</p>
<p>I vissa fall får Schulman 15 brev (<a href="https://www.expressen.se/noje/schulman-skriver-bok-om-sin-mormors-karleksaffar-med-olof-lagercrantz/">https://www.expressen.se/noje/schulman-skriver-bok-om-sin-mormors-karleksaffar-med-olof-lagercrantz/</a>), i vissa andra sväller antalet brev till 23 (<a href="https://www.hemtrevligt.se/hemmetsjournal/artiklar/artiklar/20181216/antligen-forstar-jag-upphovet-till-min-ilska/">https://www.hemtrevligt.se/hemmetsjournal/artiklar/artiklar/20181216/antligen-forstar-jag-upphovet-till-min-ilska/</a>).</p>
<p>93, Brevet citeras även i Svante Nordins,<em> Sven Stolpe</em>, s. 130–131. Det är Svante Nordin som ursprungligen upptäckte dessa brev i arkivet.</p>
<p>94, <a href="https://www.youtube.com/watch?v=iggK8LlXbak">https://www.youtube.com/watch?v=iggK8LlXbak</a></p>
<p>95, <a href="https://sverigesradio.se/avsnitt/alex-schulman-jagar-den-perfekta-historien">https://sverigesradio.se/avsnitt/alex-schulman-jagar-den-perfekta-historien</a> 44:40.</p>
<p>96, <a href="https://podcasts.nu/avsnitt/alex-och-sigges-podcast/564-slaget-om-sjalen-I5cxomN0N">https://podcasts.nu/avsnitt/alex-och-sigges-podcast/564-slaget-om-sjalen-I5cxomN0N</a>.</p>
<p>97, Jmf. <a href="https://bog.dk/alex-schulman-om-romanen-braend-alle-mine-breve/">https://bog.dk/alex-schulman-om-romanen-braend-alle-mine-breve/</a>: ”<em>[S]andheden findes ikke. Kun versioner af den.”</em></p>
<p>98, Alex Schulman, <em>Bränn alla mina brev</em>, s. 98.</p>
<p>99, <a href="https://www.svtplay.se/video/j4zo5RY/min-sanning/alex-schulman?position=313&amp;id=j4zo5RY">https://www.svtplay.se/video/j4zo5RY/min-sanning/alex-schulman?position=313&amp;id=j4zo5RY</a> 1:40.</p>
<p>100, <a href="https://podcasts.nu/avsnitt/alex-och-sigges-podcast/564-slaget-om-sjalen-I5cxomN0N">https://podcasts.nu/avsnitt/alex-och-sigges-podcast/564-slaget-om-sjalen-I5cxomN0N</a>: ”Jag måste byta genre. Jag måste byta från autofiktion till fiktion inte bara i böcker utan när det gäller mig över huvud taget … Jag måste <em>branda </em>mig själv då, som fiktion.”</p>
<p>101, Exempelvis i Söndagsintervjun: <a href="https://sverigesradio.se/avsnitt/alex-schulman-jagar-den-perfekta-historien">https://sverigesradio.se/avsnitt/alex-schulman-jagar-den-perfekta-historien</a> 43:40. Alex Schulman: ”När du säger att jag var okysst i trean – då var jag det. När du säger att jag hade en flickvän i tvåan – ja, det hade jag det. Båda historierna är lika bra. Förstår du vad jag menar?”</p>
<p>Martin Wicklin: ”Ja.”</p>
<p>102, <a href="https://www.expressen.se/tv/kultur/alex-och-sigge-vinner-pris-for-basta-kulturjournalistik/#:~:text=Podcastduon%20Alex%20Schulman%20och%20Sigge,podcast%20%22Alex%20och%20Sigge%22">https://www.expressen.se/tv/kultur/alex-och-sigge-vinner-pris-for-basta-kulturjournalistik/</a></p>
</div>
</div>
<div class="author-byline">Lapo Lappin är kulturskribent med bakgrund inom filosofin och medarbetare i Kvartals redaktion.
</div>
</div>

Redan prenumerant?
SOMMARERBJUDANDE:
3 månader helt gratis!
Ingen bindningstid.
Till erbjudandet
Eller vill du bara läsa denna artikel?

Redan prenumerant?
Testa Kvartal Total!
Första månaden gratis
Ingen bindningstid.
Till erbjudandet
Eller vill du bara läsa denna artikel?
Har du redan ett konto?
Skapa ett gratiskonto för att lyssna på Kvartals poddar helt kostnadsfritt
* Genom att skapa ett gratiskonto prenumererar du på vårt kostnadsfria nyhetsbrev – avsluta när du vill.