Så knäcktes gängen – i Chicago

<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-105254"      class = "kv-pod-holder kv-player-light  lplo " data-sid="" data-eid="" data-pid="105254" data-acurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2Uva3ZhcnRhbC9pbmxhc3Rfc2Ffa25hY2t0ZXNfZ2FuZ2VuX2lfY2hpY2Fnby5tcDM=" data-psurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2Uva2p4ajYzeWRkZXEydmgvc2Eta25hY2t0ZXMtZ2FuZ2VuLWktY2hpY2Fnby5tcDM=">  <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%2Fsa-knacktes-gangen-i-chicago%2F&amp;t=S%C3%A5+kn%C3%A4cktes+g%C3%A4ngen+%E2%80%93+i+Chicago"    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=S%C3%A5+kn%C3%A4cktes+g%C3%A4ngen+%E2%80%93+i+Chicago+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fsa-knacktes-gangen-i-chicago%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%2Fsa-knacktes-gangen-i-chicago%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Så knäcktes gängen – i Chicago&body=https://kvartal.se/artiklar/sa-knacktes-gangen-i-chicago/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/105254/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/105254/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/2024/07/Henrik_lowres2.jpg');"></div><img class="author-print-img" src="https://kvartal.se/wp-content/uploads/2024/07/Henrik_lowres2.jpg" style="display: none;">    </div>    <div class="by-disclaimer-holder" style="color: #8a3a67">Av <a href="https://kvartal.se/medverkande/henrik-hojer/">Henrik&nbsp;Höjer</a> | 6 september 2023<div class="author-desc">Henrik Höjer är Kvartals vetenskapsredaktör. Han är även historiker och författare.
</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%2Fsa-knacktes-gangen-i-chicago%2F&amp;t=S%C3%A5+kn%C3%A4cktes+g%C3%A4ngen+%E2%80%93+i+Chicago"    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=S%C3%A5+kn%C3%A4cktes+g%C3%A4ngen+%E2%80%93+i+Chicago+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fsa-knacktes-gangen-i-chicago%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%2Fsa-knacktes-gangen-i-chicago%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Så knäcktes gängen – i Chicago&body=https://kvartal.se/artiklar/sa-knacktes-gangen-i-chicago/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/105254/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/105254/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/sa-knacktes-gangen-i-chicago/?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 13 min</span></a><a href   = "https://kvartal.se/skarmlasarvanlig/105254"    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-105254">  <div class="in-short-inner">    <span class="close_button close-in-short in-short-toggle" data-articleid = "105254"></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 ">Om man ska knäcka kriminella gäng är nog beslutsamhet det viktigaste av allt. Men kanske behövs även först en vändpunkt – som leder till beslutsamheten.<sup>1</sup></p>
</div>
<div class="rest-of-article ">
<p><strong>Al Capone</strong> (1899–1947) <a href="https://www.fbi.gov/history/famous-cases/al-capone">personifierade</a> den organiserade brottsligheten och gangsterväldet i Chicago under förbudstiden på 1920-talet. Idag har han gett upphov till begreppet ”<a href="https://www.svt.se/nyheter/lokalt/sormland/al-capone-metoden-ger-miljoner">Al Capone-metoden</a>”. Men hur knäcktes han och hans gelikar?</p>
<h2>En vändpunkt</h2>
<p>I Chicago skedde vändpunkten den 14 februari 1929.</p>
<p>Innan dess hade stadens gangstrar levt rövare och liknats vid moderna pirater eller vilda västerns cowboyer av stadens journalister. De mördade visserligen varandra i stora volymer – men mycket sällan drabbades utomstående. Ligamedlemmarna var färgstarka individer som gav generöst med dricks, körde dyra bilar och i regel dog med lågskorna på. Tidningarna i Chicago rapporterade frikostigt om deras bröllop, fester, upptåg – och begravningar. Gangstrarna namngavs flitigt, och de såg det i regel som PR som stärkte deras verksamhet och våldskapital. Den nya lagen om ett nationellt alkoholförbud, som varade 1920–1933, gav den undre världen en möjlighet att expandera sin verksamhet genom alkoholsmuggling och -försäljning.</p>
<p>Sedan 1920 hade gangstern <strong>Johnny Torrio</strong> styrt den undre världen i Chicago, och delat upp staden i olika delar som de olika ligorna fick styra över. Men han skottskadades i ett mordförsök i januari 1925 och flydde staden. En 25-årig Al Capone ärvde hans organisation, som dock var i upplösning. Ett gangsterkrig utbröt, som varade till och med februari 1929. Hundratals livsstilskriminella sköts ihjäl och ytterst få dömdes. Vanligtvis sköts de på öppen gata. Eller så togs personen på en så kallad <em>one way ride</em>. Han lurades då iväg på en biltur utanför staden, där han i regel sköts i huvudet och lämnades i diket eller i baksätet på den övergivna bilen.</p>
<p>Men vid den så kallade <a href="https://en.wikipedia.org/wiki/Saint_Valentine%27s_Day_Massacre#cite_note-10">S:t Valentinsdag-massakern</a> den 14 februari 1929 skedde något nytt. Sju personer mördades i en massaker i ett garage. De tillhörde en liga som var rivaler till Capones liga, varför misstankarna gick åt hans håll. Själv hade han förstås alibi – han var i Miami då massakern skedde.</p>
<blockquote><p>Massakern blev en vändpunkt. Till och med tidningarna i Sverige skrev helsidor om anarkin i Chicago.</p></blockquote>
<p>Massakern är än i dag ouppklarad, men allt tyder på en operation av Capones organisation, sannolikt planerad av torpeden ”Machine gun” <strong>Jack McGurn</strong> – som själv också hade ett alibi via sin blonda fästmö, i pressen kallad <em>the blonde alibi</em> – hon intygade att de firat en romantisk Alla hjärtans dag på ett av stadens lyxhotell hela dagen.</p>
<figure id="attachment_105354" aria-describedby="caption-attachment-105354" style="width: 2466px" class="wp-caption alignnone"><img fetchpriority="high" decoding="async" class="wp-image-105354 size-full" src="https://kvartal.se/wp-content/uploads/2023/09/sdlPq6c3LNn0nA.jpg" alt="kvartal" width="2466" height="1920" data-wp-pid="105354" srcset="https://kvartal.se/wp-content/uploads/2023/09/sdlPq6c3LNn0nA.jpg 2466w, https://kvartal.se/wp-content/uploads/2023/09/sdlPq6c3LNn0nA-1536x1196.jpg 1536w, https://kvartal.se/wp-content/uploads/2023/09/sdlPq6c3LNn0nA-2048x1595.jpg 2048w, https://kvartal.se/wp-content/uploads/2023/09/sdlPq6c3LNn0nA-600x467.jpg 600w, https://kvartal.se/wp-content/uploads/2023/09/sdlPq6c3LNn0nA-300x234.jpg 300w, https://kvartal.se/wp-content/uploads/2023/09/sdlPq6c3LNn0nA-768x598.jpg 768w" sizes="(max-width: 2466px) 100vw, 2466px" /><figcaption id="caption-attachment-105354" class="wp-caption-text">Chicago, den 14 februari 1929. Sju personer mördades med kulsprutepistoler och hagelgevär. Foto: TT</figcaption></figure>
<p>Dådet skedde via två utklädda poliser som ”arresterade” de sju i garaget. Polisen var sällan ett problem, så de sju radade upp sig mot en vägg. Sedan anslöt sannolikt mördarna, som med två kulsprutepistoler och ett avsågat hagelgevär avslutade de sju männens liv. En var dock inte gangster, utan en optiker som brukade hänga med gänget. Det kostade honom nu livet – men detta inskärpte poängen ytterligare: Utomstående dödades i gangstervåldet (som fram till dess faktiskt nästan bara drabbat gangsters).</p>
<p>Massakern blev en vändpunkt. Till och med tidningarna i Sverige skrev helsidor om anarkin i Chicago. Stadens medborgare krävde ordning och reda. Den nytillträdde presidenten <strong>Herbert Hoover </strong>krävde att man skulle fängsla dem som gjort lagen till åtlöje i Chicago.</p>
<p>Vinden hade vänt.</p>
<h2>Stor uppmärksamhet</h2>
<p>Al Capone kände nog av opinionsläget. Han greps och dömdes till tio månaders fängelse i maj 1929 för olaga vapeninnehav i Philadelphia. Det spekulerades allmänt om att han själv arrangerat gripandet som en eftergift åt myndigheterna och som ett skydd mot hämndlystna konkurrenter. I fängelset gick han ned i vikt och kunde leva relativt fredad.</p>
<p>Men när han släpptes i mars 1930 var världen förändrad. När han kom ut ur fängelset var uppmärksamheten enorm. Våren 1930 hamnade han på <a href="https://content.time.com/time/covers/0,16641,19300324,00.html">omslaget</a> till <em>Time Magazine.</em> Samma år publicerades dessutom den första Al Capone-biografin, skriven av en Chicagojournalist med god insyn i den undre världen. Den översattes till många språk och liknades vid <em>På västfronten intet nytt</em>.</p>
<blockquote><p>Begreppet public enemy satte sig snabbt i det allmänna medvetandet.</p></blockquote>
<p>Samtidigt inleddes flera kampanjer för att få honom i fängelse igen – på betydligt längre tid: ”Get Capone” och ”public enemy”. Den senare var en lista som lanserades i april 1930 där <a href="https://www.nytimes.com/1930/04/24/archives/lists-28-gangsters-as-public-enemies-chicago-commission-names.html">28 välkända gangstrar </a>hängdes ut som allmänhetens värsta fiender. Och Capone var public enemy nummer ett. Han som person blev symbolen för förbudstidens anarki och gangstervälde.</p>
<figure id="attachment_105304" aria-describedby="caption-attachment-105304" style="width: 842px" class="wp-caption alignnone"><img decoding="async" class="wp-image-105304 size-full" src="https://kvartal.se/wp-content/uploads/2023/09/sdlV8j9-586JVM-nl.jpg" alt="kvartal" width="842" height="1024" data-wp-pid="105304" srcset="https://kvartal.se/wp-content/uploads/2023/09/sdlV8j9-586JVM-nl.jpg 842w, https://kvartal.se/wp-content/uploads/2023/09/sdlV8j9-586JVM-nl-600x730.jpg 600w, https://kvartal.se/wp-content/uploads/2023/09/sdlV8j9-586JVM-nl-247x300.jpg 247w, https://kvartal.se/wp-content/uploads/2023/09/sdlV8j9-586JVM-nl-768x934.jpg 768w" sizes="(max-width: 842px) 100vw, 842px" /><figcaption id="caption-attachment-105304" class="wp-caption-text">Al Capone i maj 1929 när han gripits för olaga vapeninnehav i Philadelphia.</figcaption></figure>
<p>Tanken var att sätta sökarljuset på dessa 28 män och att polisen skulle använda alla upptänkliga metoder och medel för att göra deras liv som kriminella outhärdligt. <em>Chicago crime commission</em> och dess ordförande, åklagaren <strong>Frank J. Loesch</strong>, låg bakom listan, och de uppmanade till alla tänkbara sätt att bli av med dessa allmänhetens fiender: deportering, razzior mot deras verksamheter, undersökningar om skattebrott, utredningar om korruption, åtal för lösdriveri och så vidare. Man uppmanade Chicagopolisen att gripa dem varhelst de kunde finna dessa män – som var välkända för allmänheten. Den romantiska glansen kring dessa kriminella skulle borstas bort.</p>
<p>Begreppet <a href="https://en.wikipedia.org/wiki/Public_enemy">public enemy</a> satte sig snabbt i det allmänna medvetandet. En gangsterfilm med titeln <em>Public enemy</em> släpptes 1931 och året därpå kom filmen <em>Scarface</em> som delvis byggde på Capones liv (filmen gjordes även som en <em>remake</em> 1983).</p>
<p>Capone blev världsberömd; allt han gjorde renderade honom massor av spaltmeter. Den rike gangstern som körde en skottsäker <a href="https://www.celebritycars.com/details-1928-cadillac-al_capone_s_bulletproof_town_sedan-used-306449.html">Cadillac</a> i skräddarsydd kostym sålde lösnummer – han inkarnerade den amerikanska drömmen på det brutalaste sätt man kan tänka sig. Hela världen intresserade sig för fenomenet Capone, som en journalist kallade USA:s främsta varumärke, lika känd i djunglerna på Java som i det öde Lappland. Sovjets blivande utrikesminister <strong>Vjatjeslav Molotov</strong> förklarade att Capone var den logiska konsekvensen av det kapitalistiska systemet. En fransk journalist såg honom som en modern <strong>Robin Hood</strong>. Och så vidare.</p>
<p>Al Capone själv gav gärna <a href="https://www.youtube.com/watch?v=u1hgHTuNvdY">intervjuer</a>, men skriverierna om honom som livsstilskriminiell blev en belastning.</p>
<h2>Depressionen spelade roll</h2>
<p>En annan faktor, som nog var minst lika viktig, var ekonomin. Börskraschen hösten 1929 innebar att det glada 1920-talet var över. Depressionen nalkades. Lönnkrogarna lockade färre gäster, jazzmusiken larmade inte lika lockande längre, utan överröstades av dånet av kraschande banker. Allt färre Chiacagobor hade råd med smuggelsprit eller spel och prostitution när soppköksköerna ringlade längsmed gatorna och arbetslösheten sköt i höjden. Bistrare tider nalkades. Helt plötsligt var tiden med smuggelsprit, vilda fester samt färgstarka och generösa gangstrar på societetskrogarna över. Toleransen för rika gangstrar minskade när folk vräktes och tvingades bo i parker och under broar. <em>Get Capone!</em></p>
<p>Den förändrade konjunkturen innebar även att gangstrarna började infiltrera fackföreningsvärlden, vilket visserligen var ekonomiskt givande – men det medförde att de fick allmänheten emot sig. Att smuggla och sälja eftertraktad alkohol var en form av public service, att suga ut fackföreningar på pengar var raka motsatsen.</p>
<p>De lokala myndigheterna hade dock varit minst sagt dåliga på att lagföra gangstrar. Polisen var delvis korrumperad; gängen hade råd med de bästa advokaterna, och den politiska viljan att driva igenom förbudslagstiftningen vacklade. Vad gäller morden fanns ett återkommande mönster: gangstermorden skedde ofta på öppen gata inför öppen ridå. Den misstänkte greps inte sällan kort därpå – men betalade borgen och kunde gå fri under utredningstiden. Det straffade sig rätt ofta genom att offrets vänner mördade honom och fallet lades ned. Och sedan började samma karusell om igen.</p>
<p>Likafullt var det extremt få som inkapaciterades under längre tid. Langarna och ligaledarna <strong>Terry ”Machine</strong> <strong>gun” Druggan</strong> (som ska ha ägt tolv bilar) och <strong>Frankie Lake</strong> dömdes för brott mot förbudslagarna, varvid de mutade fängelsepersonalen så att de kunde komma och gå som de ville i fängelset.</p>
<h2>Skattesmitning i fokus</h2>
<p>I Hollywoods version av Capones fall får ofta förbudsagenten <strong>Eliot Ness</strong> huvudrollen – han angrep visserligen basen för Capones ekonomi genom ett antal raider mot hans alkoholtillverkning – men rollen har överdrivits i Ness&#8217; självbiografi.</p>
<p>I verkligheten hade en anonym men envis tjänsteman vid skattemyndigheten huvudrollen: <strong>Elmer L. Irey</strong>.</p>
<p>Han hade efter S:t Valentinsdagmassakern fått order av president Hoover att utreda Capones ekonomi. Sedan skulle justitiedepartementet åtala honom för federalt skattebrott. Genom en serie tillfälligheter inledde Irey sin kampanj genom att testa metoden på Al Capones äldre bror <strong>Ralph ”Bottles” Capone</strong>. Han hade nämligen blivit kontaktad av skattemyndigheterna flera år tidigare. De undrade över hans ekonomi – och hans taxering. Ralph hävdade då att han försörjde sig som spelare och tjänade 20 000 dollar om året (vid denna tid tjänade en industriarbetare 100 dollar i månaden, och en ny bil kostade 400 dollar).</p>
<figure id="attachment_105257" aria-describedby="caption-attachment-105257" style="width: 767px" class="wp-caption alignnone"><img decoding="async" class="wp-image-105257 size-full" src="https://kvartal.se/wp-content/uploads/2023/09/sdlQzR5CjCIkaI-nl.jpg" alt="" width="767" height="1024" data-wp-pid="105257" srcset="https://kvartal.se/wp-content/uploads/2023/09/sdlQzR5CjCIkaI-nl.jpg 767w, https://kvartal.se/wp-content/uploads/2023/09/sdlQzR5CjCIkaI-nl-600x801.jpg 600w, https://kvartal.se/wp-content/uploads/2023/09/sdlQzR5CjCIkaI-nl-225x300.jpg 225w" sizes="(max-width: 767px) 100vw, 767px" /><figcaption id="caption-attachment-105257" class="wp-caption-text">Al Capones storebror Ralph ”Bottles” Capone fotograferad våren 1930. Foto: AP.</figcaption></figure>
<p>Ralph Capone lovade att betala skatt på dessa inkomster, men det dröjde. Efter upprepade förfrågningar från skattemyndigheterna hävdade Ralph att han numera hade gått i personlig konkurs och var pank. Irey skickade en agent till Chicago för att kolla om detta verkligen kunde stämma. Agenten återkom snart med beskedet att han önskade att han själv var lika ”pank” som Ralph Capone – som körde dyra bilar, ägde kapplöpningshästar och strödde pengar kring sig.</p>
<blockquote><p>Irey menade allvar. Snaran började dras åt.</p></blockquote>
<p>Utifrån detta faktum tog planen form, och Irey beslöt att testa den nya metoden på Ralph Capone redan hösten 1929. Åklagarna presenterade en mängd bevis för att han köpt bilar, ädelstenar, kapplöpningshästar och av allt att döma var god för tiotusentals dollar. Samtidigt hade han inte betalt en dollar i skatt, trots att utgifterna tydde på att han hade betydande inkomster. Juryn fann honom skyldig, och domen blev tre års fängelse och 10 000 dollar i böter.</p>
<p>Detta var den första ronden. Irey fick veta att president Hoover inledde varje arbetsdag med en fråga om hur det gick med Al Capone. Så Irey samlade en liten sammansvetsad grupp som skulle agera spjutspets i operationen. Agenten <strong>Frank Wilson</strong> arbetade all sin vakna tid med att tröska igenom beslagtagna papper från razzior i Chicagos alla spelhålor och lönnkrogar.</p>
<p>Gruppen skulle sedan fortsätta med Capones närmaste män, <strong>Frank Nitti</strong> och <strong>Jake Guzik</strong>. Skälen var flera: dels skulle den juridiska metoden utprövas och förfinas, dels skulle man sannolikt lättare få vittnen att ställa upp mot Al Capone om de såg att hans närmaste män verkligen dömdes till kännbara fängelsestraff. Dessutom låg det kanske element av psykologisk krigföring i det hela – Capone skulle märka hur man steg för steg närmade sig honom.</p>
<p>Både Nitti och Guzik dömdes för skattebrott, Nitti till 18 månader, Guzik till fem år.</p>
<p>Irey menade allvar. Snaran började dras åt.</p>
<h2>Dyra vanor</h2>
<p>Utredningen mot Capone tog dock tid. Men Irey och hans grupp kunde belägga att Capone köpte kostymer för 135 dollar styck, att hans telefonräkningar uppgick till 3 000 dollar om året och att han ägde hus, bilar och båtar. Capone själv började inse att han låg illa till och meddelade via sina advokater att han var villig att betala en restskatt på hisnande 700 000 dollar i utbyte mot nedlagd utredning. Svaret var nej.</p>
<figure id="attachment_105346" aria-describedby="caption-attachment-105346" style="width: 827px" class="wp-caption alignnone"><img decoding="async" class="wp-image-105346 size-full" src="https://kvartal.se/wp-content/uploads/2023/09/sdl3jnhqPe-yA-nl.jpg" alt="kvartal" width="827" height="1024" data-wp-pid="105346" srcset="https://kvartal.se/wp-content/uploads/2023/09/sdl3jnhqPe-yA-nl.jpg 827w, https://kvartal.se/wp-content/uploads/2023/09/sdl3jnhqPe-yA-nl-600x743.jpg 600w, https://kvartal.se/wp-content/uploads/2023/09/sdl3jnhqPe-yA-nl-242x300.jpg 242w, https://kvartal.se/wp-content/uploads/2023/09/sdl3jnhqPe-yA-nl-768x951.jpg 768w" sizes="(max-width: 827px) 100vw, 827px" /><figcaption id="caption-attachment-105346" class="wp-caption-text">Capones medarbetare Jake Guzik, till vänster, på väg till fängelset. Foto: AP</figcaption></figure>
<p>I oktober 1931 inleddes åtalet. Det gällde inkomster på drygt 1 038 000 dollar som han inte betalt skatt på. Alla insåg att de verkliga inkomsterna var betydligt högre, men detta borde räcka för ett längre fängelsestraff. En lång rad personer vittnade om Capones vanor. De bestod av hotellanställda, juvelerare, klädhandlare, bilförsäljare, slaktare och så vidare. De flesta utgifter hade Capone betalt kontant från en mycket tjock sedelbunt, berättade de. Rättegången varade i elva dagar – och bestod huvudsakligen av vittnesmål om ett slösaktigt liv.</p>
<p>Sedan föll domen: elva års fängelse, 50 000 dollar i böter och 8 000 dollar i rättegångskostnader.</p>
<p>Al Capone lämnade rättegångssalen som en <a href="https://www.youtube.com/watch?v=oEjsE6q_Z9Q">dömd man</a>. ”Oj, man skulle kunna tro att det var Mussolini som kom gående”, var Capones kommentar till pressuppbådet.</p>
<p>Public enemy-listan kanske var ett PR-trick. Men likafullt satte listan strålkastarljuset på 28 notoriska gangstrar. När de började inkapaciteras förvandlades dessa levande reklampelare för en kriminell livsstil till alltmer avskräckande exempel. En efter en fälldes de – eller stupade i ligakrigen. År 1934 hade 15 av de 28 dömts till längre fängelsestraff, nio var döda och en hade deporterats. De resterande tre hade gått under jorden och var på flykt undan rättvisan.</p>
<figure id="attachment_105259" aria-describedby="caption-attachment-105259" style="width: 743px" class="wp-caption alignnone"><img decoding="async" class="wp-image-105259 size-full" src="https://kvartal.se/wp-content/uploads/2023/09/sdlMFeT09J_kgo-nl.jpg" alt="" width="743" height="1024" data-wp-pid="105259" srcset="https://kvartal.se/wp-content/uploads/2023/09/sdlMFeT09J_kgo-nl.jpg 743w, https://kvartal.se/wp-content/uploads/2023/09/sdlMFeT09J_kgo-nl-600x827.jpg 600w, https://kvartal.se/wp-content/uploads/2023/09/sdlMFeT09J_kgo-nl-218x300.jpg 218w" sizes="(max-width: 743px) 100vw, 743px" /><figcaption id="caption-attachment-105259" class="wp-caption-text">Al Capone på väg till sitt fängelsestraff 1932. Foto: TT.</figcaption></figure>
<p>Men baksidan var att den undre världen nu lärde sig läxan från Capone och det vilda 1920-talet. Offentlighet och alltför mycket skjutande var dåligt både för lönsamheten och för den egna hälsan. Under 1930-talet gick det som var kvar av Capones organisation – <a href="https://en.wikipedia.org/wiki/Chicago_Outfit">the Chicago Outfit</a> – under jorden, och inrättade en serie avtal för att försöka stävja det öppna våldet, som dragit polisens och allmänhetens uppmärksamhet till dem. Och organisationen existerar ännu idag.</p>
<p>Alkoholförbudet upphävdes visserligen 1933 – det var ett misslyckande som bara skapade gangsterism och korruption. Men faktum är att flera av gängen knäcktes innan dess. Lagen hade mycket svag legitimitet i USA:s storstäder, det var en puritansk landsbygd som drivit igenom den.</p>
<h2>Lärdomar för idag</h2>
<p>”Det gängse antagandet att problemet med pojkbrottsligheten kan lösas genom att bygga fler lekplatser och sociala centra i gängområdet är fullständigt felaktigt.” Detta kan man läsa i sociologen <strong>Frederic M Thrashers</strong> studie<em> Gänget. En studie av 1 313 gäng i Chicago</em> (Égalié 2020). Den utkom för första gången 1927 och är något av en samhällsvetenskaplig klassiker. Den bygger på sju års forskningsarbete bland Chicagos ungdomsgäng på 1920-talet.</p>
<p>Thrasher var alltså kritisk till den redan då florerande teorin om att fritidsgårdar och liknande skulle motverka kriminalitet, vilket även sågats av <a href="https://kvartal.se/artiklar/myten-om-fritidsgarden/">forskningen idag.</a> Han menar att det är bättre att motverka skolk från skolan, som ofta är den allra första indikatorn på gängtillhörighet, samt ge killarna bättre förebilder än de rika gangstrar som levde rövare i Chicago på 1920-talet.</p>
<blockquote><p>Mänskligheten har vänt negativa utvecklingsspiraler otaliga gånger tidigare.</p></blockquote>
<p>Jag skrev om Thrashers studie i Svenska Dagbladet <a href="https://www.svd.se/a/56LkwO/skrammande-aktuellt-om-chicagos-gangkrig">häromåret</a>: ”Thrasher poängterar även att fattigdom i sig inte orsakar brottslighet, även om gängen var vanligast i Chicagos fattigaste delar. Han pekar i stället på social desorganisering som en viktig orsak – gänget fyller ett tomrum, skapar identitet, bygger gemenskap och ger inte minst skydd mot andra gäng. Även migrationen till ett nytt och främmande land ger framför allt pojkarna och de unga männen en ny typ av frihet, som ofta kan vara svår att hantera på ett konstruktivt sätt om man inte kan koderna eller förstår normerna.”</p>
<p>Detta är alltså kunskaper som förelåg för nästan 100 år sedan och som forskats fram i Chicago. De borde kunna tas tillvara i dagens Sverige.</p>
<p>Övriga lärdomar från Ireys insats verkar vara: Beslutsamhet, metod, hårt arbete. Beslutsamheten skapas som sagt inte sällan av vändpunkter – när någon går över en viss gräns. Metod skapas av kreativitet och erfarenhet. Och det hårda arbetet handlar om envishet och tålamod.</p>
<figure id="attachment_105276" aria-describedby="caption-attachment-105276" style="width: 1024px" class="wp-caption alignnone"><img decoding="async" class="wp-image-105276 size-full" src="https://kvartal.se/wp-content/uploads/2023/09/sdlXCEpCNA5UmQ-nl.jpg" alt="kvartal" width="1024" height="532" data-wp-pid="105276" srcset="https://kvartal.se/wp-content/uploads/2023/09/sdlXCEpCNA5UmQ-nl.jpg 1024w, https://kvartal.se/wp-content/uploads/2023/09/sdlXCEpCNA5UmQ-nl-600x312.jpg 600w, https://kvartal.se/wp-content/uploads/2023/09/sdlXCEpCNA5UmQ-nl-300x156.jpg 300w, https://kvartal.se/wp-content/uploads/2023/09/sdlXCEpCNA5UmQ-nl-768x399.jpg 768w" sizes="(max-width: 1024px) 100vw, 1024px" /><figcaption id="caption-attachment-105276" class="wp-caption-text">Fängelseön Alcatraz i San Francisco, där Al Capone avtjänade delar av sitt fängelsestraff åren 1934–1939. Foto: Eric Risberg /TT</figcaption></figure>
<p>Man hör ibland toner av defaitism i dagens Sverige: Det är kört. Det är för sent. Skjutandet breder ut sig – det är bara att försöka hålla sig undan.</p>
<p>Men mänskligheten har vänt negativa utvecklingsspiraler otaliga gånger tidigare. Det är bara att öppna en historiebok. Visst – romarriket har fallit, svältkatastrofer har utbrutit, totalitära idéer har brett ut sig, världskrig har utkämpats och epidemier har svept över kontinenter. Men mänskligheten har alltid – <em>alltid</em> – rest sig och gått vidare. Lite klokare, och mycket erfarnare. Idag är vi intelligentare, friskare och mer välutbildade än någonsin tidigare. Vi borde klara gängen.</p>
<p>Men – tyvärr – verkar vi inte ha nått vändpunkten än.</p>
<div class="notes-wrapper"><a class="shadow-button noselect show-notes"  data-articleid="105254">  <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>
<ol>
<li>Denna text bygger huvudsakligen på min bok <a href="https://www.albertbonniersforlag.se/bocker/150103/al-capone/"><em>Al Capone. Gangstern och den amerikanska drömmen</em></a> (Albert Bonniers förlag, 2009). Den bygger i sin tur främst på samtida journalistik, memoarer, samtida kriminologi och den nutida forskningen i frågan.</li>
</ol>
</div>
</div>
<div class="author-byline">Henrik Höjer är Kvartals vetenskapsredaktör. Han är även historiker och författare.
</div>
</div>
