Vägen till mordet på Mikael

<div class="kvartal-meta clearfix" style="color: ">Av <a href="https://kvartal.se/medverkande/karl-enn/">Karl&nbsp;Enn</a> | 15 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%2Fvagen-till-mordet-pa-mikael%2F&amp;t=V%C3%A4gen+till+mordet+p%C3%A5+Mikael"    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=V%C3%A4gen+till+mordet+p%C3%A5+Mikael+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fvagen-till-mordet-pa-mikael%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%2Fvagen-till-mordet-pa-mikael%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Vägen till mordet på Mikael&body=https://kvartal.se/artiklar/vagen-till-mordet-pa-mikael/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/170706/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%2Fvagen-till-mordet-pa-mikael%2F&amp;t=V%C3%A4gen+till+mordet+p%C3%A5+Mikael"    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=V%C3%A4gen+till+mordet+p%C3%A5+Mikael+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fvagen-till-mordet-pa-mikael%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%2Fvagen-till-mordet-pa-mikael%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Vägen till mordet på Mikael&body=https://kvartal.se/artiklar/vagen-till-mordet-pa-mikael/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/170706/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 12 min</span></a><a href   = "https://kvartal.se/skarmlasarvanlig/a0809cf8-dfd3-454b-8cd7-d8a4e8d43868"    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-170706">  <div class="in-short-inner">    <span class="close_button close-in-short in-short-toggle" data-articleid = "170706"></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 ">Neo: <em>Jag och min pappa skulle cykla till simhallen.</em></p>
<p>SOS-operatör: <em>Ja?</em></p>
<p>Neo: <em>Och nu, nu så var det några, tre ungar som, som han som… sköt honom.</em></p>
<p>SOS-operatör: <em>Vad, vad gjorde de för någonting?</em></p>
<p>Neo: <em>De sköt han.</em></p>
<p>SOS-operatör: <em>Sköt de din pappa?</em></p>
<p>Neo:<em> Ja.</em></p>
</div>
<div class="rest-of-article ">
<h2>Mohammeds våldsamma väg</h2>
<p>Några månader tidigare, under hösten 2023, sveper en aldrig tidigare skådad våldsvåg landet. I oktober rymmer 17-årige Mohammed från ett jourhem i Skåne och blir efterlyst. Han är född i Irak men uppvuxen med sin mamma och flera syskon i Skärholmen. Redan som 15-åring hade det kommit in ett tiotal orosanmälningar för honom. Han fick våldsamma utbrott och var utåtagerande mot lärare – även fysiskt. Han hade svårt att kontrollera känslor och hade ett våldsamt beteende. Omfattande sociala insatser och olika placeringar har inte hjälpt.</p>
<p>I ett yttrande står exempelvis: ”Mohammed flyttar hem och utredningen avslutas utan insats då mottagligheten bedöms vara icke existerande.”</p>
<p>I mitten av december fångar övervakningskameror i Vårberg centrum en maskerad person som går omkring och tycks söka efter någon. Under jackan bär han ett automatvapen. Två dagar senare får han dock syn på tilltänkta måltavlor och avlossar skott i Vårberg centrum. Måltavlorna klarar sig oskadda. Det är Mohammed som misstänks hålla i vapnet. Polisen kopplar honom till Skärholmsfalangen, som är allierad med den ökända Vårbynätverket. Motståndarna i Vårbergsfalangen söker sig istället mot Foxtrot, som leds av <strong>Rawa Majid</strong> – känd som ”Kurdiske räven”.</p>
<p>Strax innan nyår får Mohammed tag på ännu en fiende. Offret förs ner i en källare och får en pistol intryckt i munnen. Övergreppet filmas med en mobiltelefon. Offret blir även skjutet, men överlever. När ljudet av skottet klingar av har 54 människor skjutits ihjäl under året. Flera har varit ”icke-involverade”, polisens benämning på personer som inte är kriminella.</p>
<h2>”Tack för att du sa ifrån”</h2>
<p><strong>Aneta Demir</strong> och hennes familj kommer från Polen, men flyttade till Sverige med förhoppningen om att få ett bättre liv.</p>
<p>Hon och hennes lillebror <strong>Mikael Janicki</strong> hamnade i Vårberg, sydväst om Stockholm. Mikael utbildade sig till snickare och jobbade upp sig till driftsledare. Han träffade en kvinna och 2012 föddes sonen <strong>Neo</strong>.</p>
<p>– Mikael älskade att jobba och var jättesocial, och de hade flyttat till Enskede, berättar Aneta.</p>
<p>Vi ses hemma i hennes radhus i södra Botkyrka, där hon bor tillsammans med maken Elias. Då och då kommer något av deras barn in i vardagsrummet för att fråga något, eller förse sig med en kaka. Rummet är ljust och smakfullt inrett, men vissa föremål bryter av. På en möbel står flera porträtt på Mikael, flankerade av blommor, ljus och kort med små texter.</p>
<p>Något år efter att Neo hade fötts fick Mikael en hjärnblödning. Förhållandet hade redan tagit slut, och nu kunde han inte heller jobba. Han blev förändrad, fick hjärntrötthet och depressioner, och utvecklade något av en social fobi. Aneta blev en god man åt Mikael. Det sista året hyrde han ut sin lägenhet och bodde i ett rum hemma hos mamman i Vårby gård.</p>
<p>I en vas med röda rosor sitter ett vitt kort nedstucket. Texten lyder: ”Tack för att du sa ifrån. Hela Sverige tänker på dig. Vila i frid.”</p>
<figure id="attachment_170818" aria-describedby="caption-attachment-170818" style="width: 1000px" class="wp-caption alignnone"><img fetchpriority="high" decoding="async" class="wp-image-170818 size-full" src="https://kvartal.se/wp-content/uploads/2025/03/Mikael-1.jpg" alt="" width="1000" height="975" data-wp-pid="170716" srcset="https://kvartal.se/wp-content/uploads/2025/03/Mikael-1.jpg 1000w, https://kvartal.se/wp-content/uploads/2025/03/Mikael-1-300x293.jpg 300w, https://kvartal.se/wp-content/uploads/2025/03/Mikael-1-768x749.jpg 768w, https://kvartal.se/wp-content/uploads/2025/03/Mikael-1-600x585.jpg 600w" sizes="(max-width: 1000px) 100vw, 1000px" /><figcaption id="caption-attachment-170818" class="wp-caption-text"><em>Minnesbild av den mördade Mikael hemma hos storasyster Aneta Demir. Foto: Karl Enn.</em></figcaption></figure>
<p>Aneta beskriver sin bror som snäll och hjälpsam, och som en person som inte gillade orättvisor. Hjärnblödningen hade gjort honom mer känslig på något sätt.</p>
<h2>Vänskapen med Adrianas mamma</h2>
<p>Ofta var Anetas bästa vän <strong>Susanne</strong> och hennes dotter <strong>Adriana</strong>, 12 år, på plats när Mikael kom på besök. En kväll i slutet av juli 2020 skulle Susanne och hennes man resa utomlands, men Adriana ville vara hemma hos sin pappa. Men när pappan arbetade natt smet Adriana ut och träffade två vänner. De gick till McDonalds i Hallunda, samtidigt som ett tungt beväpnat gäng körde omkring och letade efter fiender ur Vårbynätverket. Skyttarna missade de tilltänkta måltavlorna men sköt Adriana. Hon hade hamnat mitt i en tioårig gängkonflikt som bottnade i osämja mellan två barndomsvänner. Mikael blev väldigt tagen av mordet på 12-åriga Adriana. Det gick inte att prata med honom om det.</p>
<p>Liksom många andra hoppas Anetas familj att mordet på Adriana ska vara en vändpunkt för det eskalerande våldet. Det blir det inte. När 2022 går mot sitt slut har 47 människor skjutits ihjäl på öppen gata. Inför valet 2022 när <strong>Ulf Kristersson</strong> (M) och <strong>Magdalena Andersson </strong>(S) debatterar gängkriminalitet i SVT finns Susanne på plats och frågar varför hennes dotter behövde dö.</p>
<p>Aneta har följt med till studion för att stötta. Hon reagerar på att Magdalena Andersson inte går fram till Susanne för att hälsa.</p>
<p>– Hon tittade knappt åt Susanne. Efteråt höll Magdalena en ros i sin hand, och jag tänkte att hon kanske skulle ge den till Susanne. Men hon gick bara därifrån. Jag satt på en stol och tänkte – hur kan man vara så kall?</p>
<h2>Civilkuragets död</h2>
<p>Två män döms till livstids fängelse för mordet på Adriana. Och efter att polisen fått tillgång till gängens krypterade chattar blir många gängkriminella dömda till långa fängelsestraff, inklusive stora delar av Vårbynätverket. Men när valåret 2022 går mot sitt slut har ändå 62 människor skjutits ihjäl på öppen gata. Och 2023 noterar polisen nya allianser och att allt yngre personer håller i vapnen.</p>
<p>I början av 2024 hittar polisen åter Mohammed. Han finns i en lägenhet i Danderyd – som Skärholmsfalangen svarar för &#8211; där det ligger knark och skyddsvästar. ”Det var för polisen uppenbart att Mohammed hade utnyttjats av äldre kriminella och riskerade att fortsätta utnyttjas på grund av sin låga ålder”, skriver polisen. Den här gången placeras Hassan utanför fastlandet – på ett HVB-hem på Gotland.</p>
<p>Det går mot ljusare tider. En dag i april åker Aneta hem till sin mamma i Vårby, där Mikael också bor. Hon ska hämta några möbler.</p>
<p>Aneta märker hur lillebrodern verkar lite stressad. Mikael hjälper Aneta att bära ut saker till bilen. Hon ser att han har börjat odlat skägg, och att han använder en liten kam.</p>
<p>Det ser ut som min dotters kam, säger Aneta och skrattar. Vill du låna en? Mikael svarar att det är en jättedyr specialkam.</p>
<p>– Jag är i alla fall glad att vi kunde skratta det sista vi gjorde.</p>
<p>Några dagar passerar. Det blir onsdag den 10 april 2024. På eftermiddagen ska Mikael och sonen Neo cykla till badhuset i Skärholmen. Det är en fin dag. En övervakningskamera fångar dem när de cyklar längs en trottoar. En stund senare rullar de nedför en liten backe och kör ner i gångtunneln som leder till badhuset. Mohammed är åter på rymmen, och har tagit sig tillbaka till fastlandet. I tunneln står ett gäng yngre killar. Någon säger något när Mikael och Neo rullar förbi och parkerar cyklarna borta vid badhuset. Mikael säger åt Neo att låsa cykeln och vänta, innan han går tillbaka till killarna i gångtunneln.</p>
<figure id="attachment_170817" aria-describedby="caption-attachment-170817" style="width: 1000px" class="wp-caption alignnone"><img decoding="async" class="wp-image-170817 size-full" src="https://kvartal.se/wp-content/uploads/2025/03/Mikael-2.jpg" alt="" width="1000" height="1333" data-wp-pid="170718" srcset="https://kvartal.se/wp-content/uploads/2025/03/Mikael-2.jpg 1000w, https://kvartal.se/wp-content/uploads/2025/03/Mikael-2-225x300.jpg 225w, https://kvartal.se/wp-content/uploads/2025/03/Mikael-2-768x1024.jpg 768w, https://kvartal.se/wp-content/uploads/2025/03/Mikael-2-600x800.jpg 600w" sizes="(max-width: 1000px) 100vw, 1000px" /><figcaption id="caption-attachment-170817" class="wp-caption-text"><em>Foto: Karl Enn.</em></figcaption></figure>
<p>Aneta är på jobbet vid Kungens kurva och pratar med en kund. Hon trycker bort flera samtal från maken Elias innan hon kan gå in på kontoret och svara. Hon tycker att hans röst låter märklig, och hans ord går inte in.</p>
<p>– Jag fattade verkligen ingenting. Varför skulle Mikael ha blivit skjuten? Det var så många tankar och frågor på samma gång.</p>
<p>Hon bryter ihop, och gråter så mycket att hon känner att hon inte kan visa sig för kunderna. Elias får hämta henne, hon klarar inte av att köra. Nyheten om att en 39-årig man skjutits framför ögonen på sin tolvårige son kommer upp på skärmen.</p>
<p>Under bilfärden mot polisstationen i Flemingsberg – dit Neo har körts – ringer hon runt till olika akutmottagningar. Hon får inte fram någon mer information. Det ger ett visst hopp. Vid polisstationen släpps Aneta och Elias först inte in utan hänvisas till en bänk. Det är kallt. Efter en stund får de dock komma in i receptionen. Ingen säger något.</p>
<p>I sin mobil kan hon läsa nyheten om att den 39-årige pappan har avlidit. Det kommer ta lång tid innan det verkligen sjunker in.</p>
<p>– Nu förstår jag Adrianas mamma Susanne lite mer, nu när jag är på offersidan. Jag har inte förlorat ett barn – som är det allra värsta – men nu har jag också förlorat en anhörig på exakt samma meningslösa sätt, säger Aneta.</p>
<p>Några dagar senare kommer hon själv figurera i medierna då hon på mordplatsen konfronterar Magdalena Andersson framför tv-kamerorna. Aneta känner en enorm frustration då hon tycker att politiker pratar mycket, men att det händer mindre i praktiken.</p>
<p>Klippet får stor spridning.</p>
<p>– Det var inte planerat. Det hade bara suttit i mig sedan partiledardebatten. Jag bara exploderade.</p>
<h2><strong>Sonen utsätts igen i en gångtunnel</strong></h2>
<p>Någon dag senare grips Mohammed – igen. Den här gången i en lägenhet i Eskilstuna. När pistolen som användes vid mordet på Mikael så småningom hittas, finns hans dna på den. Flera personer grips som misstänkta för skyddande av brottsling. Men det är en annan händelse som kommer påverka Anetas familj ännu mer.</p>
<p>Ungefär en månad efter mordet ringer Neo upp Aneta. Hon hör orden ”pistol” och ”tunnel”. En stund tidigare har hennes son Liam och Neo gett sig ut på en tur med en ny elsparkcykel. I en gångtunnel blir de konfronterade av några killar. En av killarna stoppar handen i jackfickan och säger att de kommer att dödas om de inte lämnar ifrån sig cykeln.</p>
<p>– Vi kastade oss i bilen och körde till tunneln. Jag fick flashbacks från det som hade hänt Mikael. Det enda jag kunde tänka på var att nu är det min son som ligger i tunneln.</p>
<p>Väl på plats inser hon att både hennes son och Liam är oskadda – i alla fall fysiskt.</p>
<p>– Min son var helt vit i ansiktet, skakade och grät. Det var bara fruktansvärt.</p>
<p>Polisen kommer till platsen. De misstänkta har försvunnit. Anmälan läggs ner samma dag. Rädslan kommer att sitta i betydligt längre.</p>
<h2><strong>Ett dödande skott i bröstet</strong></h2>
<p>Det har blivit januari när mordrättegången inleds i en säkerhetssal i Stockholms tingsrätt. När Neos samtal till SOS Alarm spelas upp gråter många. Mellan åhörarna och de inblandade sträcker sig ett säkerhetsglas. Vid bänken närmast glaset sitter de åtalade uppradade tillsammans med sina advokater. Bakom Mohammed sitter två vakter.</p>
<p>Han är klädd i ljus tröja, mörka byxor och svarta sneakers. På bänken framför honom ligger en snusdosa.</p>
<p>En av de åtalade – en 18-åring – sitter för sig själv, längre fram i salen. Han har under polisförhören till viss del pratat, och medgett att han var i tunneln då skotten avlossades. Under rättegången är han mer fåordig. Nu frågas han ut av målsägandebiträdet, som sitter bredvid Aneta, hennes mamma och Neos mamma.</p>
<p>När Mikael gick fram till gänget ska han ha sagt något om att inte fråga om hasch, och även nämnt sin son.</p>
<p>Målsägandebiträdet: Vad händer efter det?</p>
<p>18-åringen: Det blir bråk och tjafs.</p>
<p>Målsägandebiträdet: Var kom vapnet ifrån?</p>
<p>18-åringen: Jag såg inte var det kom ifrån.</p>
<p>Mikael ska ha försökt att få tag på vapnet. På en skärm visas foton från tunneln, där markeringar återger hur personerna ska ha rört sig. Mohammed lutar huvudet mot armen när han blickar mot skärmen. Mikaels mamma lägger armen om Aneta.</p>
<p>Ett skott träffade Mikael i buken. Det andra skottet – som var dödande – träffade honom i bröstet. Efteråt flydde gänget. 18-åringen var enligt domen med och tvättade rent cykeln som gängen hade med sig i tunneln.</p>
<p>På häktet mådde han väldigt dåligt när han svarade på polisens frågor, berättar han. Men han lyckades fortsätta plugga naturvetenskap, inte minst tack vare en ”fantastisk rektor”.</p>
<p>– Sämre mådde du inte än att du kunde koncentrera dig på tentorna, säger vice chefsåklagare <strong>Ove Jäverfält.</strong></p>
<h2>Ryktena på Flashback</h2>
<p>Åklagaren yrkade på maxstraff för Mohammed. Det innebär 14 års fängelse för mord och för de andra brotten han åtalats för. Det är på grund av hans låga ålder, 17 år. Straffvärdet är annars livstids fängelse.</p>
<p>På forumet Flashback har mordet diskuterats flitigt, och det faktum att Mikael – enligt utredningen – hade rester av cannabis i blodet. Jag ställer frågan till åklagaren, om det fanns någon sorts koppling mellan Mikael och gänget.</p>
<p>– Nej, det är inget som vi har påstått och det är inget som har framkommit i utredningen heller.</p>
<blockquote><p>De köpte min röst och det är otroligt kränkande</p></blockquote>
<p>Förutom 18-åringen och Mohammed har ytterligare en åtalad berättat att han var i tunneln när skotten avlossades. Alla tre säger sig dock vara oskyldiga.</p>
<p>– Allt fokus har varit på att det är min klient som är gärningspersonen, och jag menar att det inte är styrkt. Vi påstår att det har funnits minst ytterligare en person på platsen – som inte är identifierad – och det styrks av vittnesuppgifter, säger advokat <strong>Harri Keränen</strong>, som försvarar Mohammed.</p>
<p>Advokaten berättar att Mohammed – förutom grovt vapenbrott – erkänner viss inblandning i händelsen när en kille fördes ner i en källare i Vårberg, och fick en pistolpipa instoppad i munnen.</p>
<p>Han medger att han har levt ett stökigt liv och umgåtts med, som han uttrycker det, ”busiga personer”, men förnekar bestämt att det är han som är skytten.</p>
<p>Någon dag innan domen faller pratar jag med Aneta igen. Hon beskriver rättegången som ”sjuk”.</p>
<p>– Han som åtalats för att ha skjutit ihjäl min bror tittade ner och vägrade möta våra blickar. Våra liv har blivit förstörda och det är som att känslorna exploderar inom en, men ändå sitter man där tyst och snällt dag efter dag, säger Aneta.</p>
<p>Hon berättar om hur flera av de åtalade inte verkade förstå allvaret då de log och fnittrade. Hon ville berätta om Mikael – hur han var som människa – och deras relation. Men hon fick inte berätta om Mikael eftersom Mohammeds försvarar vitsordade skadeståndsanspråket, det vill säga gick med på den summa som Aneta hade begärt.</p>
<p>– De köpte min röst och det är otroligt kränkande. Jag tror att de var rädda för vad jag skulle säga och måla upp en fin bild av honom. Det var precis samma sak i rättegången om mordet på Adriana. De åtalade där ville inte höra Susanne prata, så de gick med på skadeståndet. Det säger kanske något.</p>
<p>Mohammed döms till 14 års fängelse. Domen kommer överklagas.</p>
<div class="author-byline">Karl Enn är journalist och författare till boken <em>Den sista sommaren – när gängen mördade ett barn</em>.<br />
&nbsp;
</div>
</div>
