Kramgoa minnen från ett land som inte längre finns

<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%2Fkramgoa-minnen-fran-ett-land-som-inte-langre-finns%2F&amp;t=Kramgoa+minnen+fr%C3%A5n+ett+land+som+inte+l%C3%A4ngre+finns"    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=Kramgoa+minnen+fr%C3%A5n+ett+land+som+inte+l%C3%A4ngre+finns+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fkramgoa-minnen-fran-ett-land-som-inte-langre-finns%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%2Fkramgoa-minnen-fran-ett-land-som-inte-langre-finns%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Kramgoa minnen från ett land som inte längre finns&body=https://kvartal.se/artiklar/kramgoa-minnen-fran-ett-land-som-inte-langre-finns/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/184212/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="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/2023/09/anna-karin-w.jpg');"></div><img class="author-print-img" src="https://kvartal.se/wp-content/uploads/2023/09/anna-karin-w.jpg" style="display: none;">    </div>    <div class="by-disclaimer-holder" style="color: #8a3a67">Av <a href="https://kvartal.se/medverkande/anna-karin-wyndhamn/">Anna-Karin&nbsp;Wyndhamn</a> | 13 augusti 2025<div class="author-desc">Anna-Karin Wyndhamn är forskare och skribent.
</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%2Fkramgoa-minnen-fran-ett-land-som-inte-langre-finns%2F&amp;t=Kramgoa+minnen+fr%C3%A5n+ett+land+som+inte+l%C3%A4ngre+finns"    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=Kramgoa+minnen+fr%C3%A5n+ett+land+som+inte+l%C3%A4ngre+finns+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fkramgoa-minnen-fran-ett-land-som-inte-langre-finns%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%2Fkramgoa-minnen-fran-ett-land-som-inte-langre-finns%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Kramgoa minnen från ett land som inte längre finns&body=https://kvartal.se/artiklar/kramgoa-minnen-fran-ett-land-som-inte-langre-finns/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/184212/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 8 min</span></a><a href   = "https://kvartal.se/skarmlasarvanlig/da0e8303-7361-40f2-b2bf-9e65c938a233"    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-184212">  <div class="in-short-inner">    <span class="close_button close-in-short in-short-toggle" data-articleid = "184212"></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 ">Får jag lov? Så skulle vi ställa frågan och samtidigt sträcka ut en öppen hand mot den vi bjöd upp.</p>
<p>Det var veckans sista lektion och dags att öva pardans.</p>
</div>
<div class="rest-of-article ">
<p>Bänkarna hade vi med gemensamma krafter föst till klassrummets långsidor. Operationen förvandlade golvet till dansbana. Vår lärare satte sig vid pianot och spelade en foxtrot som uppvärmning, medan vi mellanstadieelever försökte greppa rätt fattning och räkna steg. Två fram och ett tillbaka &#8211; fnissanfall &#8211; två fram och ett tillbaka. När det blev dags för tango hände det att vi välte varandra.</p>
<p>Min byskola låg i ett eget universum, fri från både pedagogiska trender och smakdomare. Den träning som min lärare ledde passade perfekt in i livet på den skånska landsbygden. Under min barndom på åttiotalet var stora gillen med ”kasedans” till mycket lokala dansband en del av årscykeln. Ung och gammal blandades och låtmixen av covers speglade åldersspannet: <em>I en liten fiskehamn</em>. <em>Mjölnarens Irene</em>. <em>Änglahunden</em>. <em>Hallå Mary Lou</em>. <em>Peta in en pinne i brasan</em>. Att dansband och hela kulturen runt musiken betraktades med illa dolt förakt av storstadseliten, visste mitt barn-jag inget om. Musiken som de breda lagren använde för att sätta guldkant på tillvaron, avfärdades som kommersiella pekoral. Dansbanden sålde fantastiskt många skivor, men räknades inte på riktigt. Det var folkligt och saknade förfining. Men det var då.</p>
<blockquote><p>Alla nynnade med och mindes hur bra det var.</p></blockquote>
<p><span style="font-weight: 400;">Just nu upplever den svenska dansbandsmusiken och dess forna glansperiod en påtaglig uppvärdering. Töntstämpeln är bortlyft och från alla håll strömmar kärlek till den tidigare så hånade genren. I antologin <em>Kramgoa texter: Hur dansbanden förändrade Sverige</em> (Timbro 2025) vittnar en räcka namnkunniga skribenter om sitt varma förhållande till pardans och svensk dansbandsmusik. Dansbanden upphöjs till ”en av Sveriges största kulturströmningar” av <strong>PM Nilsson</strong>. ”Dess plats i svensk kanon är redan säkrad” skriver <strong>Andreas Johansson Heinö</strong> om den musikgenre som gett landet ”många odödliga låtar” och enorma försäljningsframgångar. Det var, konstateras i ett annat kapitel, dansbandsmusiken som ”förde svenskarna samman”. Parallellt har den ljusa dokumentären om dansbandsfestivalen i Malung haft premiär.<sup>1</sup> I ett inslag i <em>Talkshow i P1</em> diskuterades filmen ingående och de båda programledarna bjöd på personliga favoriter ur låtskatten.<sup>2</sup> I SVT:s <em>Go’kväll</em> hyllades den svenska dansbandsmusiken från förr i ett eget specialavsnitt.<sup>3</sup> Alla nynnade med och mindes hur bra det var. Under sommaren utkom den första delen i en svensk trilogi om dansband. <em>Snurra min jord</em> (Mondial 2025) är pepprad med <em>feelgood</em>-referenser till dansbandsklassiker från åttio- och nittiotalet. Det är till låtlistan med kramgoa hits som berättelsens huvudpersoner flyr när vardagen och livet bjuder besvikelser. Genom alla romantiska förvecklingar löper dansbandsveckan i Malung som en gemensam hägring. Det är dit de fiktiva karaktärerna strävar, övertygade om att pardansen kommer att rädda dem. Också på den politiska och högst verkliga scenen månar man plötsligt om dansbanden. Regeringen har föreslagit en sänkning av den så kallade dansbandsmomsen.<sup>4</sup> Lagom till starten av – <em>wait for it</em> – dansbandsfestivalen i Malung meddelade Socialdemokraterna att även de anser att momsen bör sänkas.<sup>5 6</sup></span><span style="font-weight: 400;"> </span></p>
<h2>En nationell madeleinekaka</h2>
<p>Det är främst de allra sista decennierna på nittonhundratalet som står ut som återkommande referenspunkt när låtar och band nämns i sammanhangen ovan, inte den samtida dansbandsmusiken. Den nya har i stället funnit en arena i Epa-kulturen, för vilken låtar anpassas för att ge dunk och bas i A-traktorernas anläggningar.<sup>7</sup> Hur kan man förklara och förstå vurmen för svensk, klassisk dansbandsmusik? Jag tror tidens gång med djupgående förändringar av Sverige och sättet vi lever på successivt förvandlat dansbandskulturens storhetstid till en nationell madeleinekaka, begärlig för alla som var med. I den gamla musiken hör vi ljudet av ett fjärran liv och drömmer oss tillbaka till en era då vi träffades, pratade och höll om varandra i stället för att scrolla i ensamhet. De gamla låtkatalogerna påminner inte bara om umgängesformer från förr; genom musiken strömmar också tryggheten, tilliten och sammanhållningen som vi tog för given. Sverige är ett annat land nu.</p>
<blockquote><p>Vid korsvirkesgården tog programledaren Lasse Holmqvist emot gästerna som gladlynt värdshusvärd, omgiven av gäss.</p></blockquote>
<p>Fenomenet är inte nytt. I perioder av skarp samhällsförändring som griper in i levnadsvillkor och normer är det naturligt att blicka bakåt och gripa efter sådant som erinrar om stilla lycka i en skyddad och förutsägbar tillvaro. Inte för att man motsätter sig förändring i sig, utan för att det som försvunnit lämnar ett tomrum. Femtio- och sextiotalets kraftiga urbanisering genererade nya livsstilsmönster bland alla de som övergav landsbygden för industrijobb och hyreskasern. Ur detta skifte stiger i populärkulturen en nostalgi över det agrara liv som många nyligen lämnat. I det urskånska underhållningsprogrammet <em>Bialitt</em> som började sändas 1961 är landsbygdsromantiken slående.<sup>8</sup> Vid korsvirkesgården tog programledaren <strong>Lasse Holmqvist</strong> emot gästerna som gladlynt värdshusvärd, omgiven av gäss. Inne i mangårdsbyggnaden, det vill säga studion i Malmö, var det dans, sång, mat och fullt med folk. Tv-tittarna som satt i lägenheter skulle känna glädjen och gemenskapen i storstugan, precis som förr i tiden. Samma år slog sånggruppen Göingeflickorna igenom med den supersentimentala brevvisan <em>Kära mor</em> där avsändaren saknar gården, sjön och ängen.<sup>9</sup> Systrarna i gruppen bar alltid hembygdsdräkt. Stilen, tematiken och vemodet var de långt ifrån ensamma om. Det var många gamla moraklockor, gistna grindar och kistor på vinden. Längtan bort<sup>10</sup> och längtan hem<sup>11</sup> löper som en röd tråd genom decennierna. Mycket var raka motsatsen till radikalt, progressivt och upproriskt under sextio- och sjuttiotalen, i alla fall sett till vad vanligt folk lyssnade till, tittade på och tyckte om.</p>
<h2>På dansgolvet suddades skillnaderna ut</h2>
<p>Faktum är att det var i ett underhållningsprogram inte helt olikt <em>Bialitt</em> som dansbanden kom att få sitt breda tv-genomslag. <em>Nygammalt</em> hade premiär 1971 och var en återkommande del av helgutbudet fram till åttiotalets allra sista år.<sup>12</sup> Det spelades in på Cirkus i Stockholm och leddes av <strong>Bosse Larsson</strong>, som i en tidigare programserie från Skansen fört fram gammeldans.<sup>13</sup> Den fanns med här också: i en uppbyggd gärdsgård dekorerad med björkris snurrade folkdanslag runt i hambo, vals och snoa till fiol och dragspel. I avsnitt efter avsnitt. Snart kom emellertid en del av det ”nya” i <em>Nygammalt</em> bestå i gästande dansband som bjöd på andra rytmer. Kavajärmarna rullades upp och björkriset åkte ut. Hembygdsgårdscenografin lämnade plats för den kulturyttring och umgängesform som vi nu, många år senare, har lagt ett skimmer över och traktar efter.</p>
<p>Och inte undra på det i en tid då gemenskap och livsmening är bristvaror, så pass att landet behöver en nationell strategi mot ensamhet<sup>14</sup> och en utredning om den låga nativiteten.<sup>15</sup> Vår tid kännetecknas dessvärre av alienation och psykisk ohälsa, inte av tillhörighet och tillförsikt. Dansbandsmusiken har som sagt fått en renässans i film, böcker och media. Nu pratar tyckare annorlunda om både genren och epoken, men uppsvinget har ingen motsvarighet i par på golvet. Man sitter och lyssnar, sägs det (Malung undantaget). Mönstret är samma på nattklubbar,<sup>16</sup> dit allt färre och färre söker sig.<sup>17</sup> På nätets olika forum fläker vi ut oss lite till mans, men i den analoga världen har särskilt unga människor blivit introverta, dystra till sinnet och snudd på kyska.<sup>18</sup> Inget positivt kommer av en utveckling där vi isolerar oss från att faktiskt mötas. En halvsvettig tryckare ger nämligen mer än bara en chans att klämma lite.</p>
<blockquote><p>I den ringlande kön in till palatset som svalde 800 gäster spirar hoppet om att träffa någon.</p></blockquote>
<p>I en gammal dokumentär skildras nittiotalets dansbandsmecka Sandgrund i Karlstad.<sup>19</sup> I den ringlande kön in till palatset som svalde 800 gäster spirar hoppet om att träffa någon. Just denna kväll kan det ske till tonerna av <strong>Lotta Engbergs</strong> orkester. Ung och gammal står på rad för samma sak: under några timmar vill de komma andra nära. Den som bjuder upp och får ja har tillåtelse att lägga armarna runt en främling. Gunnar går till dansen nästan alla kvällar i veckan. Det är lika nytt varje gång, säger han och förklarar: ”Dansandet är ett instrument för att vara tillsammans och de som förlöjligar den förstår inte hur oändligt värdefullt det kan vara för den som är ensam. Dansen är puffen som gör att man orkar vidare.”</p>
<p>Pardans är en genväg till otvungen kontakt med andra människor. Den ger några minuters närhet till en annan kropp. Det enda som spelar roll är att man kan följa musiken hjälpligt. För den som inte har någon särskild vän, skänker varje runda en ny chans att kanske finna en. Förutsatt att man vågar fråga.</p>
<p>Den musik som nu lyfts fram som en nationalklenod påminner oss om en tid då dans till en viss sorts musik fanns som ett socialt kitt mellan människor och generationer. Man strålade samman på dansgolvet och väl där försvann alla andra bekymmer, i alla fall tillfälligt. I dansen kände man livet i sig och var inte rädd för något annat än att kvällen skulle ta slut för fort. Allt var möjligt och allt låg öppet: en lucka av oförfalskad och delad glädje. Där fanns också en klar koreografi att följa: artig fråga med ögonkontakt, sällskap upp på golvet, två danser med en mikropaus emellan, sällskap ut från golvet igen och ett ”tack för dansen”. Det var enkelt och vackert och hoppfullt i varje steg. Jag tror det är en sådan ordning och en sådan känsla vi drömmer om att återskapa.</p>
<p>Får jag lov?</p>
<div class="notes-wrapper"><a class="shadow-button noselect show-notes"  data-articleid="184212">  <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>https://www.filmstaden.se/film/dansbandsveckan/</li>
<li><a href="https://www.sverigesradio.se/avsnitt/per-moberg-grill-skola-en-svensk-ai-och-dansbandsveckan-i-malung"><em>Per Morberg, grill-skola, en svensk AI och Dansbandsveckan i Malung</em></a> (Sveriges Radio, 2 juni 2025)</li>
<li>https://www.svtplay.se/video/eQrqDmr/gokvall/dansband</li>
<li><a href="https://www.svt.se/kultur/regeringen-vill-sanka-dansmomsen-gladjande"><em>Regeringen vill sänka dansmomsen: ”Glädjande”</em></a> (SVT, 20 maj 2025)</li>
<li>Den som arrangerar en danskväll på lokal får betala 25 procent moms på intäkterna, medan en konsert är belagd med sex procent moms.</li>
<li><a href="https://www.socialdemokraterna.se/nyheter/nyheter/2025-07-09-s-bort-med-den-orattvisa-dansbandsmomsen"><em>S: Bort med den orättvisa dansbandsmomsen</em></a> (Socialdemokraterna, 9 juli 2025)</li>
<li><a href="https://www.sverigesradio.se/artikel/donnez-om-trenden-med-epa-dunk-na-ut-till-ny-generation"><em>Donnez om trenden med epa-dunk: ”Nå ut till ny generation”</em></a> (Sveriges Radio, 27 juli 2023)</li>
<li>https://www.youtube.com/watch?v=tBMgJfvmc20</li>
<li>https://www.youtube.com/watch?v=1c87RFNqLw0</li>
<li>https://www.youtube.com/watch?v=G96v-xztQH8</li>
<li>https://www.youtube.com/watch?v=VoG_LRt3Iq4</li>
<li>https://www.svtplay.se/nygammalt</li>
<li>https://www.youtube.com/watch?v=32YVLAnVh5g</li>
<li><a href="https://www.folkhalsomyndigheten.se/livsvillkor-levnadsvanor/psykisk-halsa-och-suicidprevention/nationell-strategi-mot-ensamhet/"><em>Nationell strategi mot ensamhet</em></a> (Folkhälsomyndigheten, 28 februari 2025)</li>
<li><a href="https://regeringen.se/pressmeddelanden/2025/07/ny-utredning-for-att-forsta-och-vanda-ett-minskat-barnafodande/"><em>Ny utredning för att förstå och vända ett minskat barnafödande</em></a> (Regeringskansliet, 1 juli 2025)</li>
<li><a href="https://www.na.se/2025-05-30/darfor-dansar-unga-mindre-i-dag-alla-sitter-ner/"><em>Därför dansar unga mindre i dag – ”Alla sitter ner”</em></a> (Nerikes Allehanda, 30 maj 2025)</li>
<li><a href="https://www.svt.se/nyheter/lokalt/skane/forskaren-darfor-gar-farre-unga-pa-nattklubb?"><em>Forskaren: Därför går färre unga på nattklubb</em></a> (SVT, 8 oktober 2024)</li>
<li><a href="https://www.tv4.se/artikel/hKLO1iSH59AjWqx5m7Idi/unga-mindre-intresserade-av-sex-och-fest"><em>Generationen som vill bestämma – men inte ligga: ”Konservativ riktning”</em></a> (TV4, 13 februari 2025)</li>
<li><a href="https://www.svtplay.se/video/eERQyNj/far-jag-lov"><em>Får jag lov</em></a> (SVT Play, 3 april 2017)</li>
</ol>
</div>
</div>
<div class="author-byline">Anna-Karin Wyndhamn är forskare och skribent.
</div>
</div>
