Att älska en pedofil

<div class="kvartal-meta clearfix" style="color: ">Av <a href="https://kvartal.se/medverkande/jens-ganman/">Jens&nbsp;Ganman</a> | 19 mars 2025<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%2Fatt-alska-en-pedofil%2F&amp;t=Att+%C3%A4lska+en+pedofil"    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=Att+%C3%A4lska+en+pedofil+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fatt-alska-en-pedofil%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%2Fatt-alska-en-pedofil%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Att älska en pedofil&body=https://kvartal.se/artiklar/att-alska-en-pedofil/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/170903/utskrift"    target  = "_blank"    class   = "pr-link"    title   = "Skriv ut"    onclick = ""><i class="ti-printer 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="kv-art-ext-sep"></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%2Fatt-alska-en-pedofil%2F&amp;t=Att+%C3%A4lska+en+pedofil"    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=Att+%C3%A4lska+en+pedofil+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fatt-alska-en-pedofil%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%2Fatt-alska-en-pedofil%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Att älska en pedofil&body=https://kvartal.se/artiklar/att-alska-en-pedofil/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/170903/utskrift"    target  = "_blank"    class   = "pr-link"    title   = "Skriv ut"    onclick = ""><i class="ti-printer 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 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 33 min</span></a><a href   = "https://kvartal.se/skarmlasarvanlig/71874897-d56d-42de-9f54-5d4feee3111d"    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-170903">  <div class="in-short-inner">    <span class="close_button close-in-short in-short-toggle" data-articleid = "170903"></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 "><strong>Luka</strong> sitter lutad över sin bärbara dator när jag och min researcher <strong>Sanna</strong> kommer in i det kvalmiga konferensrummet på Södermalm. Vi eskorteras av Lukas advokat som säger att han är med på mötet för att se till att ”allt går civiliserat till”. Lukas flickvän, trebarnsmamman <strong>Maria</strong>, är också där.</p>
<p>Hennes ögon skjuter blixtar.</p>
</div>
<div class="rest-of-article ">
<p>Mot mig framför allt. Hon och Luka är ett team, det märks, och deras fokus just nu ligger på att få mig att erkänna – på band – att jag pressat Luka till den här intervjun. Och att jag gjort honom arbetslös eftersom jag kontaktat flera av de företag han arbetat som konsult åt. Han menar att mina kontakter har lett till att han fått sparken, att han inte längre – som han skriver i ett sms – ”kan betala skatt”.</p>
<p>På ett av företagen, som tillhör Sveriges allra största, var de dock mycket tacksamma över att jag informerade dem om att en av deras konsulter suttit anhållen, misstänkt för bland annat innehav av grovt sexuellt övergreppsmaterial med barn. Inte minst med tanke på en annan historia: en av Sveriges största distributörer av ”barnpornografi” <em>(ett märkligt ord även om rättssystemet fortfarande använder det)</em> jobbade hos dem under 2020 och blev avslöjad. Företagets säkerhetsavdelning hade just hämtat sig från den smällen när jag kontaktade dem och berättade om att de hade en liknande figur på lönelistan.</p>
<p>Av förklarliga skäl ser Luka inte på saken på samma sätt. Han är fruktansvärt irriterad över att vi tänker skriva om honom.</p>
<p>”Den här intervjun är villkorad!” säger han strängt och blänger på mig. ”Jag vill att du slutar att kontakta min familj och fråga dem om de kan ställa upp och bli intervjuade!”</p>
<p>Jag förklarar att jag inte kan gå med på några sådana villkor och får också förklara att det är så här det går till när reportrar gräver kring brottsmisstänkta; man frågar personer i den misstänktes närhet om de har något att berätta. För övrigt kontaktade jag hans ex-fruar i ett enda syfte: jag gjorde det för att få hjälp att identifiera bilden på den lilla flicka han lagt ut i olika chattkonversationer.</p>
<p>Marias barn.</p>
<p>Hon som sitter där bredvid honom just nu.</p>
<p>Luka har fått läsa inledningen på vårt reportage. Där nämner vi att han gett sina barn en mycket specifik julklapp – han skröt om den för <strong>Joanna</strong> i en av chattarna.</p>
<p>”Hur tror det att det skulle kännas för mina barn att få läsa om detta?!”, morrar Luka och stirrar stint på mig.</p>
<p>Jag tänker: ”Hur hade det känts för <strong>Sebastians</strong> tvååriga dotter om du och Joanna våldtagit henne? Medan hennes pappa filmade? Hur skulle det känns för Sebastians fru? Mammans barn?”</p>
<p>Jag biter mig i tungan.</p>
<p>Luka är så långt inne i sitt eget missbruk, och i sin febriga desperation att försvara sig själv, sina handlingar, att han antagligen inte förstår resonemanget över huvud taget. Det märks att han heller inte förstår varför just <em>han</em> är så intressant för oss, fast på ett sätt är han inte det. Inte som person, men som företeelse. Det är samma sak som med Sebastian. Jag visste inte vilka dessa två män var förrän jag fick tillgång till chattarna där man ser deras ansikten och namn.</p>
<p>Och fantasier.</p>
<p>Men nu vet jag. Och jag försöker förstå hur Luka (och Sebastian) kunnat segla fram i tillvaron i så många år utan att folk runt omkring dem anat minsta lilla. Folk går in på Dumpen.se och förfasar sig över de groteska karaktärerna där. Många av dem är udda, kantstötta, tragiska figurer. Missbrukare, män med lågstatusyrken… så kallade ”reflexvästar”. Med hjälp av sina egna fördomar är det inte svårt att föreställa sig att såna skulle kunna begå övergrepp.</p>
<p>Luka och Sebastian representerar ett annat slags djur.</p>
<p>Båda är välutbildade och verbala, intresserade av frågor som rör teknik, juridik, moral och filosofi.</p>
<p>…och spädbarn.</p>
<p>…och lamm och hästar och hundar.</p>
<p>I en av sina många chattar med ”medpedofiler” skojar Luka om att ”suga ettårs kuk”. Hans chattpartner skrattar med, men det finns ett allvar i botten. Sammanhanget är glasklart: de letar efter likasinnade. Människor som tycker om att förgripa sig sexuellt på mycket små barn.</p>
<p><img fetchpriority="high" decoding="async" class="alignnone wp-image-171232 size-full" src="https://kvartal.se/wp-content/uploads/2025/03/Print2.jpg" alt="" width="1000" height="1541" data-wp-pid="170994" srcset="https://kvartal.se/wp-content/uploads/2025/03/Print2.jpg 1000w, https://kvartal.se/wp-content/uploads/2025/03/Print2-195x300.jpg 195w, https://kvartal.se/wp-content/uploads/2025/03/Print2-768x1183.jpg 768w, https://kvartal.se/wp-content/uploads/2025/03/Print2-997x1536.jpg 997w, https://kvartal.se/wp-content/uploads/2025/03/Print2-600x925.jpg 600w" sizes="(max-width: 1000px) 100vw, 1000px" /></p>
<p>Jag tänker på det där jag sitter, med Lukas och Sebastians chattloggar i bakhuvudet. Luka vet inte hur mycket jag vet. Men han vet <em>att</em> jag vet. Och det gör honom ursinnig. Stämningen i det lilla konferensrummet är så dålig, så förtätad, att den går att skära med kniv. Luka mal på om alla fel jag gjort i min granskning av honom. Han anser sig utsatt för ett journalistiskt övergrepp och återkommer hela tiden till att jag borde ”tänka på barnen”. <em>Hans</em> barn. Det blir absurt och jag tänker för mig själv: ”Du får slå dig trött.”</p>
<p>Efter en halvtimmes jiddrande hit och dit frågar jag:</p>
<p>”Har du sett filmen <em>Daisy’s destruction</em>?”</p>
<p>Och i samma sekund som jag nämner den titeln tänds en märklig glimt i Lukas ljusblå ögon.</p>
<p>”Jag har sett enstaka klipp…”, säger han och rösten byter tonläge. Med ens blir den låg och entonig. Ömklig. Vädjande.</p>
<p>”Det är en film som slutar med att en nioårig flicka får gräva sin egen grav”, fortsätter jag, ”innan hon stryps… mördas… och läggs i graven. Har du delat klipp från den filmen vidare till andra användare?”</p>
<p>Luka stönar tyst.</p>
<p>”Jag vet inte, jag tror inte det… kanske… jag har ingen aning.”</p>
<p>Det är här han reser sig upp och börjar hyperventilera. Det är också här som Maria vänder blicken mot honom i stället för mot mig och min researcher. Man ser hur tårarna stiger i hennes ögon.</p>
<p>”Luka… på riktigt?”</p>
<p>Jag frågar vad det var på klippen som Luka såg. Han sväljer:</p>
<p>”Det var en väldigt elak kvinna som eh… gör… hemska saker mot ett barn… droppar varmt vax på henne bland annat.”</p>
<p>Advokaten tittar i golvet och skruvar på sig. Jag tänker på hur andra, poliser och utredare, beskriver det där klippet. En nioårig flicka hängs upp i rep – upp och ner. Sedan hälls hett stearin rakt ner i hennes underliv. En av poliserna som utredde fallet sa att det ”bästa” med <em>Daisy’s destruction</em> är när flickan stryps och dör för då slipper hon äntligen sina plågoandar.</p>
<p>Döden kommer som en befriare.</p>
<p>Det märks att Luka återupplever klippen i sitt huvud där vi sitter. Jag kan inte bevisa att det är så, men hans beteende förändras radikalt när vi kommer in på de här sakerna och på andra saker som han trodde (eller hoppades) att jag inte kände till. Som sagt: han förstår inte att jag har läst de chattar han haft även med andra pedofiler som <strong>”Sava”</strong> och <strong>”Tobias”</strong>… Han förstår inte att det är en och samma person som ligger bakom alla dessa konton. Han vet inte att jag känner till att han diskuterat detaljerade övergrepp på djur med andra människor, att han varit inne och skrivit i gruppen ”0–2 år gamla”, att han sett – och vidarebefordrat – filmen med <strong>”Daisy”</strong>, att han berättat om tidigare övergrepp på spädbarn för lettiska ”Sava”.</p>
<p>”I en av konversationerna beskriver du ett detaljerat övergrepp av en sexmånaders baby”, säger jag.</p>
<p>Luka skakar på huvudet. Ögonen är stora och runda.</p>
<p>”Det är bara fantasier.”</p>
<p>”Det är väldigt detaljerat som sagt… vill du att jag ska läsa upp det?”</p>
<p>Luka blir svart i blicken.</p>
<p>”<em>Nu tycker jag att det blir osmakligt!</em>”</p>
<p>Han menar att det är osmakligt att jag ska läsa upp det han skrivit i en av chattarna – inte osmakligt att han själv skrivit det. Och han vidhåller att allt, precis allt han beskrivit i sina chattar, är fantasier.</p>
<p>”Jag har aldrig förgripit mig på någon!”</p>
<p>”Du berättar om lamm”, envisas jag, “när du chattar med signaturen Sava i Lettland. Du beskriver att man inte behöver tänka på konsekvenserna med dem. Vad menar du med det?”</p>
<p>Luka skakar på huvudet.</p>
<p>”Jag vet inte… det är bara en fantasi…”</p>
<p>När vi kommer in på hans vänskap med Sebastian säger han att de bara träffats en gång.</p>
<p>”Vad gjorde ni då?”</p>
<p>”Tittade på barnporr.”</p>
<p>”<em>Daisy’s destruction</em>?”</p>
<p>”Eh… ah… va… nää…”</p>
<p>Han sväljer igen, förklarar att han sagt till Joanna att han och Sebastian träffats flera gånger – men bara för att invagga henne i trygghet inför det där mötet på The Bishops Arms i Gamla stan. Mötet där de skulle planera våldtäkten av Sebastians tvååriga dotter. Det där mötet som bara var en ”fantasi”.</p>
<p>Jag sneglar på Maria. Hittills har hon försvarat Luka med näbbar och klor, men nu märks det att hon börjar vackla. Det är obegripligt att det tagit ända till nu. Älskar hon honom, tänker jag förvirrat? Kan man älska en sådan här mörk, manipulativ, egoistisk varelse?</p>
<p>Tydligen.</p>
<p>Och ja, jag tänker på honom så. Som en slags varelse. Jag försöker se hans människovärde, men det är svårt. Här sitter en uppbragt, ledsen, arg man som ser mycket trevlig ut… och försöker försvara sin heder, sin familj, sina barn. Men jag har läst hans chattar med olika pedofiler runt om i världen. Där är tonen en annan. Den är helt renons på medmänsklighet. Småbarn, djur… det är bara saker som man använder för sitt eget höga nöjes skull. Jag erinrar mig speciella detaljer i det han skrivit, hur han berättat att han haft häst i tjugo år:</p>
<p>”I enjoy animals, both as pets and sexually …and lambs… it feels like fucking a small child, but you don’t have to think about the consequences…”</p>
<figure id="attachment_171052" aria-describedby="caption-attachment-171052" style="width: 1000px" class="wp-caption alignnone"><img decoding="async" class="wp-image-171052 size-full" src="https://kvartal.se/wp-content/uploads/2026/03/Animals.jpg" alt="" width="1000" height="1338" data-wp-pid="170993" srcset="https://kvartal.se/wp-content/uploads/2026/03/Animals.jpg 1000w, https://kvartal.se/wp-content/uploads/2026/03/Animals-224x300.jpg 224w, https://kvartal.se/wp-content/uploads/2026/03/Animals-768x1028.jpg 768w, https://kvartal.se/wp-content/uploads/2026/03/Animals-600x803.jpg 600w" sizes="(max-width: 1000px) 100vw, 1000px" /><figcaption id="caption-attachment-171052" class="wp-caption-text"><em>Ur en chatt mellan Luka och lettiska Sava.</em></figcaption></figure>
<p>Jag tänker på att han skrivit att han ”väntar på barnbarn” och att han har ”tillgång till en 2- och 3-åring”… och hur han brukar träffa vackra kvinnor med barn, hur han försöker leka med barnen, men att det alltid slutar med att mammorna blir misstänksamma.</p>
<figure id="attachment_171048" aria-describedby="caption-attachment-171048" style="width: 1000px" class="wp-caption alignnone"><img decoding="async" class="wp-image-171048 size-full" src="https://kvartal.se/wp-content/uploads/2026/03/Print1.jpg" alt="" width="1000" height="1161" data-wp-pid="171003" srcset="https://kvartal.se/wp-content/uploads/2026/03/Print1.jpg 1000w, https://kvartal.se/wp-content/uploads/2026/03/Print1-258x300.jpg 258w, https://kvartal.se/wp-content/uploads/2026/03/Print1-768x892.jpg 768w, https://kvartal.se/wp-content/uploads/2026/03/Print1-600x697.jpg 600w" sizes="(max-width: 1000px) 100vw, 1000px" /><figcaption id="caption-attachment-171048" class="wp-caption-text"><em>Ur en chatt mellan Luka och lettiska Sava.</em></figcaption></figure>
<p>Det är en vansinnig värld han lever i. Men helt igenom en fantasivärld enligt honom själv.</p>
<p>Vad ska man tro?</p>
<h2><strong>”Vi är fortfarande ihop”</strong></h2>
<p>Det är dagen efter mötet på konferenscentret på Söder. Maria och jag träffas på ett fik på Centralen. Hon sitter bredvid mig klädd i svarta jeans, svart jumper och ett smycke med vad som ser ut att vara tre små silverhjärtan i en tunn kedja runt halsen. Hon har svårt att hålla gråten borta när hon börjar prata.</p>
<p>”Jag vill börja med att säga att jag fortfarande är ihop med Luka”, säger hon och ser på mig, halvt trotsigt, halvt vädjande.</p>
<p>”Ok”, säger jag och hinner tänka:</p>
<p>”Herregud. Stackars liten.”</p>
<p>Men jag säger:</p>
<p>”Är du så kär?”</p>
<p>Maria skrattar till. Bittert. Hon vänder sig bort, biter sig i underläppen.</p>
<p>”Det frågar alla. Och du behöver inte tala om för mig att jag borde lämna honom för det gör alla andra redan.”</p>
<p>Hon berättar att hon förlorat kontakten med både släktingar och vänner på grund av relationen med Luka. Att deras förhållande påverkar hennes arbete… hon har blivit anmäld till socialtjänsten, pappan till barnen är vansinnigt arg. Galen.</p>
<p>Förstås.</p>
<p>”Luka måste ha en uppsättning fantastiska sidor…”, tänker jag för mig själv. ”Eller så är hon bara en vanlig medberoende.”</p>
<p>Väldigt bräcklig, i vilket fall. Rösten bär inte när hon talar. Men hon ville träffas ändå. Hon skrev till mig bara några timmar efter på mötet i konferensrummet och frågade om jag var kvar i stan. Jag hade hunnit boka upp mig på annat så jag sa att vi kunde träffas idag i stället, innan mitt tåg skulle gå söderut.</p>
<p>”Den där.. …den där utprintade bilden på min dotter som du hade med dig igår”, säger hon och tittar på mig med blanka ögon, ”den där hon ligger och sover i barnvagnen…”</p>
<p>”Ja.”</p>
<p>”Jag vill att ni ska veta att jag har polisanmält Luka för att han delade den i de där grupperna. Bara så att ni vet.”</p>
<p>”Har DU polisanmält honom…?!”</p>
<p>Maria nickar.</p>
<p>”Ok? Men hur –”</p>
<p>”…och han förstår det.”</p>
<p>Jag tittar på henne. Jag vet inte vad jag ska säga. Jag tänker på det Luka skrev under bilden – som en kommentar till de andra chattkompisar han delade den med:</p>
<p>”Får min kuk att styvna i alla fall.”</p>
<p>Maria berättar att hon tvingade honom att läsa den där meningen högt för henne, medan hon satt och tittade på honom. Hon säger att hon naglade fast honom med blicken.</p>
<p>”Han har erkänt att han skrev så. Det är liksom inget snack.”</p>
<p>”Ok, men –</p>
<p>”Vänta-vänta!” Maria håller upp handen och hejdar mig. ”Låt mig tala klart… ”Hon sväljer ljudligt. ”…och efter mötet hos advokaten igår skällde jag på honom hela kvällen om den där filmen…”</p>
<p>”…<em>Daisy’s destruction</em>.”</p>
<p>”<em>Ja</em>. Och vet du: jag tror, på riktigt, att han inte minns exakt vad han delat till de andra i de där grupperna. Han har hållit på och chattat med så många olika människor så länge… i decennier…”</p>
<p>Jag nickar omärkligt. Säger inget.</p>
<p>Jag såg i Lukas ögon att han visste precis vilka han delat det vidare till. Övergrepp på barn och djur är något som fascinerar honom. Gränslöst. Och det kommer det alltid att göra. Tyvärr. Han säger att han deltar i en studie på Karolinska sjukhuset där man försöker ”behandla” hans impulser med mediciner. Han har ambitionen att bli frisk säger han. Men han kommer aldrig att bli frisk. Hans drift, hans impulser, är för starka. Det är min egen teori. Jag tror inte att sådana som han någonsin går att bota. Han har passerat för många gränser. Han och Sebastian var på väg att iscensätta ett övergrepp på en tvååring.</p>
<p>Maria berättar att efter mötet igår var hon så avståndstagande mot honom att han fick panik. När hon skulle gå och träffa mig ville Luka att hon skulle ta med sig alla hans mediciner, han litade inte på sig själv påstod han.</p>
<p>Jag tänker att han är ett svin som lägger över det på henne – det också.</p>
<p>Han lägger på denna unga trebarnsmamma att hon ska ansvara för att han inte tar livet av sig medan vi sitter här på Urban Deli på Centralen. Han är ett kräk. En fegis.</p>
<p>Jag kan inte låta bli att tänka så. Det är oprofessionellt, ur ett reporterperspektiv, men jag kan inte låta bli. För mig är det uppenbart att han använder Maria som krycka. Han har ingen annan just nu och eftersom hon älskar honom ställer hon upp till hundra procent. Hon säger att hon ”vill förstå”, att deras förhållande är långsiktigt, men att han aldrig kommer att få träffa hennes barn.</p>
<p>Jag hajar till.</p>
<p>”Aldrig?”</p>
<p>”Nej.”</p>
<p>”Det låter lite opraktiskt. I längden.”</p>
<p>”Jag vet.”</p>
<p>Hon gråter igen. Vänder sig bort. Folk skyndar förbi, på väg från och till sina tåg. Tur att de inte vet vad vi sitter och pratar om.</p>
<p>”Det finns så mycket information i Luka…”, säger Maria och ser lätt beundrande ut.</p>
<p>Hon skrattar till. Kanske åt ett fint minne hon och Luka har ihop. För de <em>har</em> ju såna. Också. Måste ha. Annars skulle hon inte försvara honom så här. <em>Allt</em> i deras korta, turbulenta relation kan inte vara mörker, samtal om övergrepp, pedofili, djursex.</p>
<p>Jag kommer mig inte för att fråga vad det där betyder: ”Mycket information…?” Innebär det mycket kunskaper? Mycket livserfarenhet? Mycket… vad?</p>
<p>Maria säger att hon ägnat månader åt att ”korsförhöra honom” om a-l-l-t. Hela hans liv. Hans chattande med andra. Hans sjuka böjelser. Hon vet vem han är, inside out. Hon säger att hon själv strulade till det för sig som ung, ordentligt, och att hon hade velat då att någon hade funnits där för henne.</p>
<p>”Alla förtjänar en andra chans.”</p>
<p>Hon tittar på mig och för en kort sekund är det svårt att inte imponeras. Jag är övertygad om att Maria menar vad hon säger. Men jag tänker också att Luka fått många andra chanser genom livet. Av sina exfruar, av andra flickvänner, av samhället…</p>
<p>Maria oroar sig för att hela den här historien ska läcka ut på Dumpen. Jag säger att jag inte vet något om det, men jag påminner om att deras redaktion dammsuger tingsrätterna efter barnövergreppsrelaterade domar och att Lukas dom nog kommer att hamna i deras händer, den också. Och att Dumpen kanske redan har delar av det material jag fått ta del av. Det cirkulerar. Om de har det, helt eller delvis, kommer de antagligen att publicera och det materialet innehåller bilder på Lukas ansikte. Sebastians namn finns med. Folk <em>kommer</em> att få veta. På ett eller annat sätt.</p>
<p>Jag frågar Maria vad hon tror om övergreppet på en baby som Luka berättade om.</p>
<p>”Jag tror verkligen att det bara var en fantasi”, säger hon och lägger till att Luka kan vara ”oerhört naiv”.</p>
<p>”När jag sa till honom att ’det fattar du väl att alla som läser din beskrivning av den där våldtäkten på bäbisen kommer att utgå från att du verkligen gjort det… du kommer aldrig att kunna bevisa att det var en fantasi…’ …då såg jag paniken i hans ögon, att det var först då han förstod, första gången han såg det så.”</p>
<p>Han har alltså fått höra det där flera gånger, tänker jag. Från flera ex.</p>
<p>Vi sitter tysta en stund. Det känns konstigt att sitta intill denna bleka, unga kvinna. Igår hatade hon mig innerligt. Jag kunde känna hatet stråla mot mig som en svart våg därinne i konferensrummet på advokatbyrån. Hon önskade mig ont. Nu känns hon svag och vek. Tillintetgjord. Nästan mjuk. Ber om förståelse.</p>
<p>Nåd.</p>
<p>Jag fingrar på mitt nyinköpta exemplar av den franska författarinnan <strong>Vanessa Springoras</strong> <em>Consent</em> (<em>Samtycket</em>) som ligger i en Ica-tygkasse på stolen bredvid. Den handlar om en ung flicka som utnyttjats av en omhuldad kulturprofil. Jag har ingen lust att läsa den. Inte just nu i alla fall. Det här reportaget börjar tära på mig. Det är bara en massa vidrigheter, övergrepp och mänsklig olycka.</p>
<p>Sorg. Ilska. Sunk. Solkighet.</p>
<p>Jag vill skrika till Maria:</p>
<p><em>”MEN FÖR HELVETE!!! TA BARNEN OCH SPRING!!!”</em></p>
<p>Men jag sitter tyst.</p>
<p>Tittar ut på den myllrande ankomsthallen. Jag tänker att en dag kommer hon att fatta, fast först måste Luka bedra henne med en annan kvinna, skaffa en annan krycka. Eller – gud förbjude – göra något mot hennes barn i ett obevakat ögonblick. Igen: han är ett kräk. En narcissist. Hans sentimentala utbrott kring sina egna barn dagen innan fyller mig med avsmak. Han bryr sig inte ett dugg om dem. Han bryr sig bara om sig själv. Han orkar inte med att inte bli älskad, och barnen och Maria älskar honom. Fortfarande. De är hans livlina. Det är vad det handlar om. Hans tårar är krokodiltårar. Det måste vara så. Eller?</p>
<p>Senare den dagen skriver Maria ett meddelande till mig på Messenger.</p>
<p>”Min bägare börjar fyllas känner jag…”, apropå hur jobbig relationen med Luka börjar bli.</p>
<p>Och i ett annat:</p>
<p>”Kanske är jag bara dum och envis.”</p>
<p>”Du är en bra tjej”, svarar jag. ”Smart och rolig.”</p>
<p>Jag tänker på hennes spända anletsdrag när vi satt där på Centralen. Hur hon höll ihop benen hårt, armarna, händerna… som om hon verkligen på riktigt, fysiskt, var på väg att falla isär.</p>
<p>I små, små bitar.</p>
<h2><strong>Tårar</strong></h2>
<p>Jag försöker berätta om det jag skriver för mina vänner. Ingen är särskilt intresserad. De flesta slår ifrån sig:</p>
<p><em>”Jag vill inte höra… Jag klarar inte av sånt där. Det är så äckligt!”</em></p>
<p>Samtidigt vill alla att pedofilerna ska stoppas och att lagstiftningen ska bli bättre. Alla vill att polisens arbete ska bli mer effektivt, men ingen vill göra grovjobbet. Ingen vill skita ner händerna, utom <a href="http://dumpen.se/">Dumpen.se</a> och de kuratorer, poliser, advokater och åklagare som har den otacksamma, omänskliga, uppgiften att sitta och titta igenom – och lyssna till – olika former av övergreppsmaterial. Material som sedan ska ligga till grund för olika åtal. Och till läkandeprocesser hos offer och anhöriga.</p>
<p>Maria sa att hon <em>avskydde </em>Dumpen när vi satt på Centralen och pratade, och det är märkligt: Hon såg nästan mer störd ut över deras verksamhet, över deras ”pöbelvälde”, än de saker Luka utsatt henne (och andra) för. Hur är det möjligt?</p>
<p>Samtidigt som vi sitter där och pratar bestämmer sig ledningen för advokatfirman där Sebastian arbetar att informera sin personal om det som hänt. Man samlas i ett konferensrum och vd:n Martin tar till orda. Han berättar att Sebastian är borta permanent från organisationen och att han inte kommer att komma tillbaka. Martin berättar om skälet till detta – att Sebastian suttit anhållen av polis för innehav av grovt övergreppsmaterial. Han har också försökt pimpa ut sin egen, knappt tvååriga dotter, till två andra pedofiler.</p>
<p>Det blir knäpptyst i rummet.</p>
<p>Allt syre försvinner.</p>
<p>Det här är en samling välutbildade, intelligenta män och kvinnor. Flera av dem har erfarenhet av att ta del av känsligt material i sitt arbete. De förstår, på ett teoretiskt plan, att sådant här existerar, att det finns människor som ägnar sig åt detta, men inte en av deras egna. Inte<em> Sebastian.</em> Det får inte vara sant. Kan inte vara.</p>
<p>Någon börjar gråta. Martin tittar i golvet. Det är svårt att möta personalens blickar i det här läget. Det blir för mycket att ta in, han förstår det, men i slutändan var han tvungen att berätta. Ärendet har gått ända till HR-chefen i England. PR-skadan för företaget kan bli avsevärd, även om ingen hade en aning om vad Sebastian sysslar med på sin fritid. Men det kan bli guilt by association, som så ofta numera i Sverige.</p>
<p>Han harklar sig:</p>
<p>”Ni som känner att ni inte orkar jobba vidare idag får gå hem.”</p>
<p>Flera av de närvarande väljer att göra det, även om det bara handlar om en kort respit. Det de just fått höra kommer att förfölja dem i många år.</p>
<p>Vemsomhelst.</p>
<p>Det kan verkligen vara vemsomhelst.</p>
<p>***</p>
<p>Under arbetet med att kartlägga Luka och Sebastian hör jag av mig till en högt uppsatt person på Finansinspektionen. Han är nära vän till en av de två. Jag frågar om mannen känner till den obehagliga historien och han svarar nej, kort och en aning irriterat. Hans reaktion är inte särskilt konstig. Ingen vill ju höra talas om sådant här – övergrepp på småbarn, det värsta man kan tänka sig – och än mindre vill man höra att en av ens nära vänner kan vara inblandad i något sånt.</p>
<p>Det går någon dag och det ringer på Messenger. Det är en känd kvinna som ringer upp och vill prata. Oklart varför. Vi har aldrig träffats förut, men vi har gemensamma bekanta och vid ett tillfälle har kvinnan skrivit till mig och sökt kontakt. Nu vill hon tipsa om en politisk skandal som hon tycker att jag borde intressera mig för. Jag förstår inte riktigt varför, men det handlar om någon från Liberalerna som ”borde granskas”. Kvinnan går runt inne på Östermalmshallen samtidigt som hon pratar, spänt och en aning osammanhängande.</p>
<p>Det är ett konstigt samtal. När jag nystar lite i det hela senare ser jag att kvinnans lika kände man – en tidigare minister – är vän med mannen på Finansinspektionen.</p>
<p>Jag har inga belägg för min teori, men jag får intrycket att någon försöker distrahera mig.</p>
<h2><strong>”Var är alla era frågor?”</strong></h2>
<p>Jag får ett meddelande från Lukas nuvarande flickvän Maria. Hon är upprörd.</p>
<p>Hon skriver:</p>
<p><em>”Ni sitter på alla hemskheter och vidriga saker som Luka har sagt. Men jag känner hans andra sidor. Vi lever tillsammans 50 procent av tiden (då jag inte har mina barn). </em></p>
<p><em>Det finns absolut ingenting som tyder på att han är en dubbelnatur i den bemärkelsen som jag tror att ni syftar på. Han är varken psykopat eller sociopat eller har några som helst sadistiska tendenser. Sådant hade märkts i en nära relation även om den inte hade märkts i mer ytliga relationer så som arbetskollegor etc.</em></p>
<p><em>Tvärtom. Han är oerhört mån om sin omgivning. Och en fantastisk varm människa med vettiga värderingar. Min oro efter intervjun är att det inte känns som att ni var/är intresserade av att förstå så som ni skrivit gång på gång i sms till Luka utan att du var intresserad av vissa specifika saker som exempelvis huruvida han tittat på den specifika filmen eller delat den eller om han vet mer om Sebastian. Utöver det ställdes egentligen inte speciellt mycket frågor.</em></p>
<p><em>Som din kollega uttryckte det ‘Han är ett totalt mörker’.</em></p>
<p><em>Nej, han är inte ett totalt mörker. Den sidan av honom är ett mörker. Han har uppenbarligen en störning av något slag. Men han är inte bara den sidan. Han är så mycket mer. Och jag tänker att vill man inte bara sätta dit och straffa eller hämnas, utan faktiskt förändra och förhindra att sånt här sker, att fler barn blir utsatta, är det en förutsättning att först ha förstått. Där finns nyckeln till att faktiskt kunna göra något långsiktigt.</em></p>
<p><em>Så var är alla era frågor?”</em></p>
<p>Den främsta frågan är nog: Hur blir man sån? Hur kan en människa bära så mycket sjukt inom sig?</p>
<p>Lukas uppväxt i förorten förefaller ha varit förvirrande. Det förekom mobbning, ett visst mått av utsatthet. Hemmiljön var av olika anledningar inte den bästa. Luka var ett känsligt barn som via kompisar och kompisars föräldrar på ett tidigt stadium exponerades för grov pornografi. Men – räcker det som förklaring? Många därute har haft en hård och förvirrande uppväxt. Det betyder inte att de per automatik börjar fantisera om att våldta djur och spädbarn. Eller att de faktiskt genomför de fruktansvärda handlingarna. Luka var några timmar ifrån att styra ihop ett möte med två andra vuxna – i akt och mening att planera våldtäkt på en försvarslös 1,5-åring.</p>
<p><em>Ur polisförhör med Luka, februari 2022:</em></p>
<p><strong><em>Misstanken stämpling till grov våldtäkt mot barn eller våldtäkt mot barn avser att du bestämt möte med en annan man som har en 1,5 årig dotter. Kan du berätta mer om den träffen?</em></strong></p>
<p><em>”Det enda som varit min intention var att få kontakt med Joanna. Hon har påstått att hon gillar små barn och då var min tanke att om jag berättar det här så kanske vi kan få kontakt… (…)… Jag har ju egentligen inte velat att det ska bli av något av med det där. Det är ingenting som jag varit med och planerat.”</em></p>
<p><strong><em>Hur tänker du kring att ni har pratat om att ses tillsammans med Sebastians då 1,5 åriga dotter?</em></strong></p>
<p><em>”…att det inte är på riktigt. Det är inte något som kommer bli av. Det var väl som en dörröppnare om jag kan säga det så… utan att det blir för konstigt…”</em></p>
<p><strong><em>Hur kommer Sebastians 1,5-åriga dotter in i den här bilden? Vad är tanken med att ni pratar om att ses?</em></strong></p>
<p><em>”…när Joanna svarade sa jag ju att det finns en kontakt här… och jag berättade att han heter Sebastian </em>(inklusive efternamn, förf.anm.)<em>… och så fick jag frågor på det. Då sa jag att det är lättare att de (två) pratar tillsammans. Jag vet att de ringdes vid. Om jag ska vara ärlig vet jag inte om han sagt ett datum… men jag vet att han sagt att han kan nu på söndag. Men jag fick intrycket att det inte skulle bli av. Från min sida drev inte jag det heller. Jag var mer intresserad av att träffa Joanna.”</em></p>
<p><strong><em>Var tanken att Sebastians dotter skulle vara med på söndag?</em></strong></p>
<p><em>”Det var ingenting bestämt. Om jag ska vara ärlig från min sida så var det inte intressant (för mig). Det som var intressant var Joanna. Jag berättar så ärligt jag kan. För min del fanns det inte en tanke att det skulle bli av.”</em></p>
<p><strong><em>Vi är tacksamma för att du berättar. Men jag är lite mer nyfiken på Sebastians del i det hela. Vad tanken var med att hans dotter skulle vara med (på mötet)? Har Sebastian sagt någonting kring det? Det är ju också det som avser vår misstanke: att det har diskuterats om att träffas i ett sexuellt sammanhang? Och att ett 1,5-årigt barn ska vara involverat?”</em></strong></p>
<p><em>”Om jag ska vara ärlig… jag kan inte säga ‘det var det där eller det där’. Jag tror inte det var någon diskussion om vad som skulle hända. Det var bara att vi skulle ses… (…)… Jag vet att Sebastian ringde mig och sen har jag haft kontakt med Joanna och då har vi pratat om att vi ska träffas… (…)… Det är inte min minnesbild att det är det jag planerat skulle hända (övergrepp på Sebastians dotter, förf. anm.). Absolut inte.”</em></p>
<p><em>(Slut på förhöret.)</em></p>
<p>Luka bestrider alltså att mötet på The Bishops Arms i Gamla stan skulle handla om ett planerat övergrepp och att han var drivande i att få till det. Igen: allt är – enligt honom, “om han ska vara ärlig” – fantasier. Han glider bara med. Han är kär i Joanna och gör allt för få att träffa henne,</p>
<p>Men för sin chattkompis – lettiska ”Sava” – beskriver Luka hur han vid ett tillfälle, när han satt barnvakt åt en tidigare flickväns bror, förgrep sig dennes nyfödda dotter. Han har skrutit för andra, främmande människor, varav flera kan ha varit pedofiler, om sin nya flickvän Maria. Han skickade till och med bilder till dem på hennes barn.</p>
<p>Så här såg det ut när han och Joanna diskuterade saken:</p>
<figure id="attachment_171233" aria-describedby="caption-attachment-171233" style="width: 1000px" class="wp-caption alignnone"><img decoding="async" class="wp-image-171233 size-full" src="https://kvartal.se/wp-content/uploads/2025/03/Print3.jpg" alt="" width="1000" height="1130" data-wp-pid="171049" srcset="https://kvartal.se/wp-content/uploads/2025/03/Print3.jpg 1000w, https://kvartal.se/wp-content/uploads/2025/03/Print3-265x300.jpg 265w, https://kvartal.se/wp-content/uploads/2025/03/Print3-768x868.jpg 768w, https://kvartal.se/wp-content/uploads/2025/03/Print3-600x678.jpg 600w" sizes="(max-width: 1000px) 100vw, 1000px" /><figcaption id="caption-attachment-171233" class="wp-caption-text"><em>Ur en chatt mellan Luka och Joanna.</em></figcaption></figure>
<p>När Luka konfronteras med dessa, explicita, chattmeddelanden i efterhand hävdar han att det aldrig hände på riktigt. Å andra sidan: Vem skulle erkänna något sådant inför en polis? Eller för en reporter?</p>
<p>Efter att ha läst det omfattande materialet om Luka, läst alla hans chattar och dessutom träffat honom öga mot öga kan jag, i vilket fall, inte skaka av mig känslan av att han faktiskt begått faktiska övergrepp mot barn. I bästa fall har han bara en mycket livlig (och pervers) fantasi. Tyvärr finns det en uppsjö av bilder och filmer på nätet som bekräftar att många pedofila ”fantasier” inte stannar på idéstadiet.</p>
<p>Ännu svårare är det att förstå Sebastian. Det finns inga spår av materiell misär och elände i hans uppväxt, men någonting måste ha hänt som gjorde honom till det han är? Man famlar efter en förklaring. Har han ramlat och slagit sig? Fått en hjärnskada? Eller är det i slutändan så enkelt som egna val? Själviskhet?</p>
<p>En annan fråga som följer på detta är den klassiska: kan en människa födas ond? Sebastian var på väg att ”låna ut” sin knappt tvååriga dotter till två andra pedofiler. Ett försvarslöst barn som behövdes ”hållas fast” eftersom hon var ”skrikig”. Hennes pappa ”varnade” de andra pedofilerna för detta, att hon var ett bråkigt barn som gjorde motstånd. <em>Var</em> dessa andra personer pedofiler? På riktigt?</p>
<p>Sebastian – med största sannolikhet.</p>
<p>Luka – troligen.</p>
<p>Joanna – nej.</p>
<p>Joanna var bara en vanlig mamma som bestämde sig för att <em>fånga </em>pedofiler – på nätet. Detta genom att utge sig för att vara någon helt annan. Hon lurade in Luka och Sebastian i en fälla. Hon investerade hundratals timmar i att tråla runt på nätet och leta efter ”offer” i stängda forum och chattgrupper. När hon fick napp överlämnade hon materialet till polisen. Med tiden blev Joanna skicklig på att förställa sig och ge männen i chattgrupperna vad de ville ha; hon spelade rollen som kvinnlig ”pedofilmamma” till perfektion, så bra att Luka under förhören på Kronobergshäktet i Stockholm utan omsvep erkänner att han blivit kär i henne. Men han upprepar också, gång på gång, att i princip allt han gjort på nätet, allt han sagt och skrivit på KIK, Snapchat och Wickr är ”fantasier”. Han menar att hans situation till största del beror på att <em>andra</em> bjöd in honom i olika förbjudna grupper. Han var för svag. Han lurades in i en värld som han egentligen inte hade något intresse av.</p>
<p>I polisförhören använder han ofta formuleringar som ”ärligt talat” och: ”om jag ska vara helt ärlig”. När samtalet kommer in på Sebastian vill han få det till att de bara träffats vid ett enda tillfälle:</p>
<p>”Nere i en tvättstuga eller något sådant… det var riktigt B.”</p>
<p>Han säger att det enda de gjorde den gången var att titta på djurporr och att Luka upplevde Sebastian som ”creepy”. För Joanna berättar han att de två träffats vid flera tillfällen, bland annat på ett hotellrum där de onanerade tillsammans till grova övergreppsfilmer på barn:</p>
<p>“Vid ett tillfälle hann vi inte mer än innanför dörren på rummet innan Sebastian drog ner byxorna och satte upp telefonen på ett bord… han tryckte igång ett klipp med grov barnporr och började runka. Han var helt besatt. Det var otäckt. Jag blev rädd för honom.”</p>
<p>Det bisarra mötet på The Bishops Arms i Gamla Stan avfärdar Luka som ett hugskott. Han säger att han kopplade ihop Joanna med Sebastian för att han ville imponera på sin nya förälskelse. Han ville ge henne sådant hon påstod sig vara intresserad av: möjligheten att utföra sexuella övergrepp på mycket små barn.</p>
<p>I förundersökningen mot Luka finns en passage där polisen frågar om han förgripit sig på sina egna barn:</p>
<p><strong><em>Vi har läst i chattar att ”Hardmannen” – som är ditt konto – har skrivit att han (du) gjort sexuella saker på sina egna barn när de var yngre? Och även på andras barn. Även barn i hans/din närhet.</em></strong></p>
<p><em>”Det är inte sant. Det är bara fantasi. Jag vill bara vara noggrann med det. Överhuvudtaget så är det en jargong i de där chattarna. Jag vet att jag har skrivit det till Joanna också, men det är inte sant.”</em></p>
<p><strong><em>Varför har du skrivit det om det inte är sant?</em></strong></p>
<p><em>”För att jag upplever att det är det som är jargongen. Jag gjorde det för att alla skriver så (i grupperna). När det gäller Joanna gjorde jag det för att verka intressant. Sen är det ju fantasier.”</em></p>
<p><strong><em>Bara så att jag förstår&#8230; den här fantasivärlden. När du skriver utifrån fantasivärlden just gällande att det har gjorts sexuella saker med barn och främst (dina) egna barn… hur fungerar det?</em></strong></p>
<p><em>”Det fungerar väl så att det är en fantasivärld. Att det inte är på riktigt. Det är inte jag. När det gäller Joanna så vet jag att hon var intresserad av det… och då ville jag ’pleasa’ för att verka intressant.”</em></p>
<p><strong><em>Har du reflekterat över varför du har skrivit om att det har begåtts sexuella övergrepp på dina egna barn? Att du uttrycker dig så i skrift till andra människor?</em></strong></p>
<p><em>”Jag tror att det jag har beskrivit här finns i min närhet på något sätt… då det är lättare att relatera till.”</em></p>
<p><strong><em>”Hardmannen” har också beskrivit mer detaljerat vad som skall ha gjorts, att det ska ha slickats, sugits, penetrerats med fingrar, kuk&#8230; att han/du träffat andra svenskar för att ha sex med barn?</em></strong></p>
<p>”Ingenting av det är sant.”</p>
<p><strong>Ingenting av det är sant?</strong></p>
<p>”Alltså <em>nej.</em>”</p>
<h2><strong>Babies and toddlers</strong></h2>
<p>I ett tidigt skede får Luka och hans nya flickvän Maria läsa ett utsnitt av det här reportaget. Luka reagerar starkt på att jag inkluderat en detalj om just hans egna barn: om en speciell julklapp de har fått. Han frågar hur jag tror att det skulle kännas för dem att läsa om sånt på nätet. Alltså samma information han själv spridit till främmande människor i grupper med namn som: ”0 till 5 år”.</p>
<p>[Bild]</p>
<p>Jag tar bort detaljen.</p>
<p>Luka och Maria, framför allt Maria, vädjar om att reportaget inte ska publiceras – med hänvisning till Lukas barn och anhöriga. Hon engagerar sig osjälviskt i deras väl och ve. Hon ber att jag inte ska publicera reportaget eftersom hon är rädd att det ska få till följd att folk ger sig på Lukas barn fysiskt, exempelvis i skolan. Överlag förefaller hon dock ha en nykter syn på mycket som rör Luka och den uppkomna situationen.</p>
<p>Vid ett tillfälle skriver hon:</p>
<p><em>”Jag tänker att om han har en chans att ändra på sig så är det nu. Med terapi, medicin och stöd. Och jag har ingen illusion om att han aldrig mer kommer sexchatta med en annan kvinna. Det är inte rimligt att anta att en missbrukare klarar av att bli fri från sitt missbruk utan återfall. Men min förhoppning och förutsättning i det här är att han ska ge fan i barnpornografi.</em></p>
<p><em>Om jag däremot orkar med återfall eller inte kan jag inte veta. Men det vore ren idioti att inte stötta honom nu om det kan bidra till att det finns en man mindre där ute som bidrar till att barn utsätts för övergrepp.”</em></p>
<p>Hon vill tro på honom. Till varje pris. Trots att hon vet, trots att han erkänt – i alla fall för andra kvinnor – att han, i längden, inte klarar av att betvinga sina inre demoner. Till slut får han alltid återfall.</p>
<p>[Bild]</p>
<p>I ett av polisförhören får Luka frågan om han hyser ett sexuellt intresse för barn. Han svarar undvikande:</p>
<p>“Vad betyder det? Menar du på riktigt? Hur ska jag definiera det?”</p>
<p>Förhörsledaren fortsätter:</p>
<p><strong><em>Berätta hur du definierar det</em></strong><em>.</em></p>
<p><em>”…det beror lite grann på var och när i tiden… De här (chatt)forumen är ju väldigt mycket just att jag blir inbjuden dit&#8230; För mig var det inga ställen som jag vanligt kunde komma åt. Jag ska inte skylla ifrån mig… men det hade inte blivit så annars av det kan jag säga… Sen kanske det är bra för då blir det stopp någonstans. Men samtidigt upplever jag inte att det varit på samma sätt tidigare. Jag har haft uppehåll. Apropå sexuella preferenser så tror jag mest att mina är vuxna kvinnor. Jag har aldrig haft sex med en man.”</em></p>
<p><strong><em>Har du haft sexuellt umgänge med barn?</em></strong></p>
<p><em>”Nej. Jag har ju egna barn. Det är en av de sakerna i livet som&#8230; Jag har tre barn så ja det är en fantasivärld…”</em></p>
<p>Efter att historien med Luka, Sebastian och Joanna avslöjats anmäler sig Luka till Anovas behandlingsprogram på Karolinska Universitetssjukhuset i Stockholm. Han säger att han inget hellre vill än att bryta sina destruktiva mönster. Han påstår att han vill ”krypa ur sitt eget skinn” och att han ångrar det han gjort. Han förstår att han skadar sina barn och anhöriga genom sitt beteende. Han säger också att han tycker att det är bra att sådana som han avslöjas och ställs till svars för vad de gjort.</p>
<p>På Karolinska behandlar man män med ”oönskad sexualitet”. Man gör det med hjälp av ett hormonpreparat (Degarelix) som i vanliga fall används som medicin vid prostatacancer. Studier har visat att det relativt snabbt går att sänka testosteronnivåerna hos individer med sexuell dragning till barn, ibland efter bara några veckors behandling. Ett välkommet hjälpmedel. Pedofili är svårt att bedriva studier på. De etiska och juridiska aspekterna gör det omöjligt att anordna kliniska studier. De studier som ändå genomförs bygger på att människor frivilligt berättar om sina tidigare erfarenheter. Inga ”nya” upplevelser får skapas, inte ens i vetenskapens namn.</p>
<p>Luka vidhåller att han aldrig spelat in eget övergreppsmaterial, men att han förstår att spridandet av sådant material i värsta fall riskerar att skapa ett sug efter nya kickar hos människor med samma böjelser som han – och i förlängningen fler offer. Även hårresande filmer som <em>Daisy’s destruction</em> blir (antagligen) vardagsmat för den som sett den om och om igen. Därför ”måste” nytt övergreppsmaterial hela tiden skapas.</p>
<p>Till vilket pris som helst.</p>
<h2><strong>Epilog</strong></h2>
<p>Ur polisens beskrivning av två av de många filmklipp som beslagtogs i samband med tillslaget mot Luka:</p>
<ol>
<li><em> ”Ett spädbarn ligger på rygg medans det blir penetrerat oralt av en mans erigerade penis vilket gör att bebisen snuttar på den då den tror att den ammar.”</em></li>
<li><em> ”Bilden visar en liten flicka liggandes på rygg med napp i munnen. Hon ligger med rumpan samt könet blottat och benen brett isär. Hon har tröja på överkroppen och naken på underkroppen. I flickans vagina har det satts in en dildo.”</em></li>
</ol>
<p>Hela det beslagtagna materialet fördelas på 2443 st datafiler som alla är att betrakta som övergreppsmaterial.</p>
<ul>
<li>1291 st bilder är att betrakta som övergreppsmaterial (barnpornografi).</li>
</ul>
<p>Av dessa är 723 st bilder är att betrakta som särskilt hänsynslöst övergreppsmaterial.</p>
<p>67 st filmer är att betrakta som övergreppsmaterial.</p>
<p>Filmernas totala speltid är ca 00:58:25.</p>
<ul>
<li>362 st filmer är att betrakta som särskilt hänsynslöst övergreppsmaterial. Filmernas totala speltid är ca 10:24:23.</li>
</ul>
<p>Bland titlarna märks: ”Newbaby2017”, ”Pedomombath” och ”Mommyplugsgirl”.</p>
<p>***</p>
<p>Under hösten 2023 skickas flera fakturor från Region Stockholm till en adress där Luka tidigt varit skriven. Fakturan avser uteblivna besök för behandling.</p>
<p>Enligt Lukas nuvarande flickvän Maria handlar det om besök som med kort varsel bokats av.</p>
<p>Hon skriver till mig att det inte betyder att han inte gått vid ett senare tillfälle.</p>
<p><em>Samtliga namn på de personer som förekommer i reportaget har bytts ut.</em></p>
<p><em>En version av reportaget har tidigare publicerats på Jens Ganmans Substack.</em></p>
<div class="author-byline"><strong>Jens Ganman</strong> är musiker och författare. Hans senaste böcker är &#8221;Det lilla landet som kunde&#8221; (2018), skriven tillsammans med <strong>Mustafa Panshiri</strong>, och romanen&nbsp;&#8221;De som kommer för att ta dig&#8221; (2017).&nbsp;
</div>
</div>
