Nu hotas den svenska livsmedelsberedskapen

<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-178367"      class = "kv-pod-holder kv-player-light  lplo " data-sid="" data-eid="" data-tis="1027" data-tin="1232" data-pid="178367" data-pty="SW5sw6RzdCBhcnRpa2VsIChTYW1ow6RsbGUp" data-pna="TnUgaG90YXMgZGVuIHN2ZW5za2EgbGl2c21lZGVsc2JlcmVkc2thcGVu" data-acurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2UvaW5sYXN0YXRleHRlci85LTAwLW51LWhvdGFzLWRlbi1zdmVuc2thLWxpdnNtZWRlbHNiZXJlZHNrYXBlbi5tcDM=" data-psurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2Uva2p4ajYzeWRkZXEydmgvOS0wMC1udS1ob3Rhcy1kZW4tc3ZlbnNrYS1saXZzbWVkZWxzYmVyZWRza2FwZW4ubXAz">  <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: ">Av <a href="https://kvartal.se/medverkande/johan-gardebo/">Johan&nbsp;Gärdebo</a> och <a href="https://kvartal.se/medverkande/stefan-hellstrand/">Stefan&nbsp;Hellstrand</a> | 15 maj 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%2Fnu-hotas-den-svenska-livsmedelsberedskapen%2F&amp;t=Nu+hotas+den+svenska+livsmedelsberedskapen"    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=Nu+hotas+den+svenska+livsmedelsberedskapen+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fnu-hotas-den-svenska-livsmedelsberedskapen%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%2Fnu-hotas-den-svenska-livsmedelsberedskapen%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Nu hotas den svenska livsmedelsberedskapen&body=https://kvartal.se/artiklar/nu-hotas-den-svenska-livsmedelsberedskapen/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/178367/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%2Fnu-hotas-den-svenska-livsmedelsberedskapen%2F&amp;t=Nu+hotas+den+svenska+livsmedelsberedskapen"    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=Nu+hotas+den+svenska+livsmedelsberedskapen+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fnu-hotas-den-svenska-livsmedelsberedskapen%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%2Fnu-hotas-den-svenska-livsmedelsberedskapen%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Nu hotas den svenska livsmedelsberedskapen&body=https://kvartal.se/artiklar/nu-hotas-den-svenska-livsmedelsberedskapen/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/178367/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 class="listen" href="https://kvartal.se/artiklar/nu-hotas-den-svenska-livsmedelsberedskapen/?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 12 min</span></a><a href   = "https://kvartal.se/skarmlasarvanlig/9c483d49-27b5-40f3-8669-dc50f78e20b1"    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-178367">  <div class="in-short-inner">    <span class="close_button close-in-short in-short-toggle" data-articleid = "178367"></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 ">När Livsmedelsverket den <a href="https://www.livsmedelsverket.se/om-oss/press/nyheter/pressmeddelanden/nya-kostrad-med-fokus-pa-mer-gront-och-mindre-sott">28 april</a> uppdaterade Sveriges kostråd, för första gången på ett årtionde, återspeglas de målkonflikter som under dessa år kommit att prägla samhällsdebatten. Klimatförändringar, kulturkrig och nu faktiskt krig. Frågan ”vad blir det till middag?” rymmer nu allt fler dimensioner.</p>
</div>
<div class="rest-of-article ">
<p>Konflikterna märktes redan i höstas då Livsmedelsverket skickade sin rapport på remiss. Kritiska kommentarer i de nära 70 remissvaren speglar hur olika intressen hungrar efter just sin bit av den nya tallriksmodellen. I december gav <a href="https://www.dn.se/sverige/kullgren-om-att-kottrekommendationerna-ska-ses-over-vill-ta-hojd/">regeringen</a> därför ett förtydligande uppdrag – gör om och gör rätt – med tydligare fokus på beredskap. Man bad alltså Livsmedelsverket att visa på om det fanns målkonflikter mellan de uppdaterade kostråden och det övergripande målet om Sveriges beredskap.</p>
<h2>Mindre kött och mejerivaror</h2>
<p>Men när Livsmedelsverket uppdaterar kostråden undanhåller de i stället information om målkonflikterna. Och de är inte ensamma om att göra så. Klimatpolitiska rådet lade i mars fram en rapport med snarlika krav och slutsatser: svenskarnas konsumtion av kött från kor och får samt av mejerivaror ska minska. Vidare hävdar man att regeringen nyttjar beredskapsargumentet i sina uppdrag till Livsmedelsverket för att helt enkelt fördröja införandet av vad Klimatpolitiska rådet anser är nödvändiga förändringar av Sveriges kostråd – för folkhälsans skull, och för klimatets.<sup>1</sup></p>
<p>De skriver: ”Genom att bromsa uppdateringen av kostråden och kräva en mer specifik analys ger regeringen intrycket att den inte fullt ut stöttar hälsofrämjande rekommendationer som även kan minska livsmedelskonsumtionens klimatpåverkan.”</p>
<p>Här ska nämnas att själva grunden för de nya kostråden utformades inom ramen för Nordiska näringsrekommendationer 2023. Det är detta faktaunderlag som Klimatpolitiska rådet hänvisar till när det nu avfärdar regeringens oro för svensk beredskap. Men rådet ger ingen analys av hur näringsrekommendationerna hanterar eventuella målkonflikter mellan Sveriges nationella konkurrenskraft respektive matförsörjningen i såväl fred som krig. Det hade heller inte gått, eftersom dessa frågor inte fanns med i uppdraget för de nordiska näringsrekommendationerna.<sup>2</sup></p>
<p>Klimatpolitiska rådet drar alltså slutsatser från ett material som inte hanterar de här sakfrågorna.</p>
<p>Etablerade medier har hittills återgivit rekommendationerna utan att närmare granska dem (<a href="https://www.dn.se/sverige/livsmedelsverket-nya-kostrad-far-liten-betydelse-for-kottbonderna/">DN</a>, <a href="https://www.sverigesradio.se/artikel/nya-kostraden-max-350-gram-rott-kott-per-vecka">SR</a>, <a href="https://www.svd.se/a/KMA7O7/livsmedelsverket-uppdaterar-kostraden-sa-ska-du-ata">SvD</a>, <a href="https://www.gp.se/nyheter/sverige/livsmedelsverkets-nya-kostrad-sa-mycket-kott-ska-du-ata.391c3cb6-2d04-4f87-ad85-4cfb9286f4af">GP</a>).</p>
<p>Samtidigt publicerar Dagens Nyheter ett upprop av 1 047 forskare från över 30 lärosäten, där man kräver att ”politiken” nu måste lyssna på vetenskapen.<sup>3</sup> Utifrån regeringens bristande intresse för Klimatpolitiska rådets rapport, där jordbruk är årets fördjupningstema, drar dessa 1 047 forskare följande slutsats: ”Att som makthavare ignorera forskningsbaserade fakta och avfärda vetenskapliga rön som ’åsikter’ underminerar grunden för ett demokratiskt och hållbart samhälle.”</p>
<p>De anser här att regeringens uppgift är att verkställa forskningens rön. Vetenskapen överordnas politiken och gör den till sitt redskap.</p>
<p>Det enklaste sättet att bemöta våra forskarkollegors ord är att återkomma till huvudfrågan: vilka är kostrådens målkonflikter? Låt oss därför titta på källorna till rekommendationerna.</p>
<p>Det axplock av kritik som vi presenterar här mot Livsmedelverkets val av ingredienser kan sammanfattas med att kostråden ger en mager meny till Sveriges beredskap, särskilt den dag angriparen knackar på dörren.</p>
<h2>Kostråden ställer folkhälsa mot beredskap</h2>
<p>Regeringens krav på beredskap är i sig inget nytt. Historiskt utvecklades Sveriges moderna kostråd under första världskrigets hungerår. Beredskap handlade dels om folkhälsa, dels om säkerhet. Kriget minskade Sveriges möjligheter till import, vilket ökade risken för såväl svält som inbördeskrig – likt våra grannar Finland vid samma tid. Brist på förnödenheter försämrade en redan spänd situation.</p>
<p>Bakgrunden till dagens uppdaterade kostråd är att regeringen givit två uppdrag med bäring på Sveriges beredskap. I det första från den <a href="https://www.regeringen.se/contentassets/2888af734a9c4254825d026b4805e4a6/uppdrag-till-livsmedelsverket-att-uppdatera-de-svenska-kostraden.pdf">15 juni 2023</a> vill man att Livsmedelsverket ska ”utifrån de nordiska näringsrekommendationerna 2023 analysera hur de miljömässiga hållbarhetsaspekterna kan påverka den svenska livsmedelsproduktionen samt uppdatera de svenska kostråden”. Det andra uppdraget gavs den <a href="https://regeringen.se/pressmeddelanden/2024/12/ytterligare-analys-behovs-i-det-fortsatta-arbetet-med-nya-kostrad/">19 december 2024</a> då regeringen menade att ”ytterligare analys behövs i det fortsatta arbetet med de nya kostråden”. Sammantaget handlar uppdragen om att Livsmedelsverket ska presentera kostråd som främjar försörjningsförmågan i kris och krig, ökar livsmedelsproduktionen och göra så utifrån livsmedel som det i Sverige finns goda naturgivna förutsättningar för att producera.</p>
<p>Hur återspeglas då frågor om folkhälsa och beredskap i de uppdaterade rekommendationerna?</p>
<p>Livsmedelsverket menar att målet för folkhälsa nås genom att minska konsumtionen av rött kött. Tanken är att svenskar ska äta högst 350 gram kött per vecka, alltså en sänkning från tidigare råd om max 500 gram. Råden framhåller också baljväxter som en daglig proteinkälla och betonar vikten av grönsaker, frukt och fullkorn. Rådet om sänkt intag av rött kött skulle förebygga över 18 000 fall av cancer och hjärt- och kärlsjukdomar årligen, enligt Livsmedelsverket.<sup>4</sup></p>
<p>Hur påverkar detta Sveriges livsmedelsberedskap? Livsmedelsverket menar, som tidigare nämnts, att beredskapen inte far illa.<sup>5</sup> Men för den som <a href="https://www.livsmedelsverket.se/globalassets/publikationsdatabas/rapporter/2025/r-2025-fordjupad-konsekvensanalys-av-kostradet-om-rott-kott-och-chark-allt.pdf">läser kostråden noggrannare</a> ter sig Livsmedelsverkets analys missvisande och motsägelsefull.</p>
<blockquote><p>En minskning av den inhemska produktionen av mjölk och av rött kött skulle öka beroendet av import&#8230;</p></blockquote>
<p>Vi börjar med rött kött: Man påstår att den nya gränsen för maximal konsumtion om 350 gram per vecka skulle vara en minskning med 30 procent jämfört med dagens konsumtion. Detta är en grov underskattning, vilket framgår genom att jämföra resultaten i Livsmedelsverkets andra rapporter.</p>
<p>Exempelvis, i en rapport från 2024 till regeringen som författats tillsammans med Folkhälsomyndigheten säger Livsmedelsverket att populationsmedelvärdet för köttkonsumtion ligger på cirka 60 procent av maxvärdet.<sup>6</sup> Det vill säga, för att se till att merparten av Sveriges befolkning håller sig under 350 gram kött per vecka så blir den egentliga nivån inte mer än 210 gram.</p>
<p>Vi får alltså en konsumtionsminskning på cirka 60 procent, inte 30 procent som Livsmedelsverket påstår om sina uppdaterade kostråd.</p>
<p>Lägger vi därtill Livsmedelsverkets bedömning av mejeriprodukter så är även den, likt den för köttet, missvisande. Livsmedelsverket menar att konsumtionen och produktionen ej påverkas. Men det krävs inte mer än att du tittar på Jordbruksverkets officiella statistik över svensk konsumtion för att kunna följa hur de uppdaterade kostråden innebär lägre mejerikonsumtion, en minskning på mellan 60 och 70 procent.<sup>7</sup></p>
<h2>Livsmedelsverkets rekommendationer slår mot landsbygden</h2>
<p>Dessa diskrepanser är inga detaljer; Livsmedelsverket påstår att effekterna på produktionen är obetydliga, när de i själva verket kommer att få omfattande konsekvenser för Sveriges livsmedelsproduktion och därmed för vår beredskap.</p>
<p>Det nordliga jordbrukets relativt sett kortare odlingssäsonger gör att kött- och mejeriprodukter ofta är de effektivaste alternativen för näringsrika livsmedel. Redan idag importeras knappt hälften av allt nötkött. En minskning av den inhemska produktionen av mjölk och av rött kött skulle öka beroendet av import, vilket är en betydande säkerhetsrisk i vår allt osäkrare geopolitiska tid. Men det är precis det man föreslår: en minskning av mjölkkonsumtionen och -produktionen med 60–70 procent. För griskött, nötkött, fårkött, viltkött och renkött är minskningen av konsumtion och produktion 60 procent. Detta föreslår Livsmedelsverket, samtidigt som man inte redovisar de faktiska effekterna som följer av sådana kostråd, och det trots att man väl känner till de officiella källor som visar att så är fallet.</p>
<p>Livsmedelsverket säger att konsumenterna bör välja svenskt kött. Men det är ett falskt argument av två skäl. Visst kan det fungera för den vanliga familjen, men för storhushåll som skolor och sjukhus är det inget alternativ. Det strider mot lagen om offentlig upphandling, såväl i Sverige som i EU. Vi kan inte särbehandla vår produktion av mjölk och kött från den i andra EU-länder. Det andra skälet är att utöver Sveriges kostråd så har EU flera regelverk vars mål är att skära ned ytterligare på mjölk och rött kött.</p>
<p>Ett exempel är EU:s vetenskapliga underlag för hållbara matsystem, med bidrag från svenska klimatpolitiska forskare om just de nordiska näringsrekommendationerna.<sup>8</sup> Utöver att nivåerna för nödvändiga proteinintag skiljer sig avsevärt mellan regelverket och studierna så lyfts en i huvudsak vegetarisk ”planetär diet” fram som modell för EU:s matsystem.<sup>9</sup></p>
<p>Dessa studier, och <a href="http://theguardian.com/environment/2014/jul/21/giving-up-beef-reduce-carbon-footprint-more-than-cars">forskarna som medverkade</a>, prioriterade djurrätt och biologisk mångfald över frågor som böndernas äganderätt och nationell suveränitet över jordbruket, vilka i stället blev frågor som man önskade skulle beslutas om på internationell nivå.</p>
<p>Det är dessa prioriteringar som vi ser lysa igenom hos Livsmedelsverket när de föreslår i en hypotetisk studie att minska Sveriges köttproduktion med 10 procent. Det skulle alltså innebära en betydande förlust för svenska bönder. På nationell nivå försvagas livsmedelskedjan. Men på lokal nivå kan konsekvenserna bli ännu större eftersom mindre jordbruk redan idag har svårt att få lönsamhet i sin verksamhet.</p>
<figure id="attachment_178434" aria-describedby="caption-attachment-178434" style="width: 1024px" class="wp-caption alignnone"><img fetchpriority="high" decoding="async" class="wp-image-178434 size-full" src="https://kvartal.se/wp-content/uploads/2025/05/sdlOJoTIaPHQ3E-nl.jpg" alt="kvartal" width="1024" height="683" data-wp-pid="178434" srcset="https://kvartal.se/wp-content/uploads/2025/05/sdlOJoTIaPHQ3E-nl.jpg 1024w, https://kvartal.se/wp-content/uploads/2025/05/sdlOJoTIaPHQ3E-nl-300x200.jpg 300w, https://kvartal.se/wp-content/uploads/2025/05/sdlOJoTIaPHQ3E-nl-768x512.jpg 768w, https://kvartal.se/wp-content/uploads/2025/05/sdlOJoTIaPHQ3E-nl-600x400.jpg 600w" sizes="(max-width: 1024px) 100vw, 1024px" /><figcaption id="caption-attachment-178434" class="wp-caption-text">Kor på Adelsö. Foto: Fredrik Sandberg /TT</figcaption></figure>
<p>Vidare är svensk boskapsskötsel inte bara en förutsättning för produktion av mat i vårt nordliga läge, och har så varit under de minst 5 000 år som Sverige haft jordbruk. Boskap spelar även en avgörande roll för att upprätthålla biologisk mångfald och öppna landskap, samt möjligheten att utnyttja betesmarker och vallodling – samtliga viktiga resurser i kristider. Ett exempel på detta är 2018, då det var extremtorka i Sverige och man tvingades till nödslakt av boskap på grund av bristande möjligheter att samla foder.</p>
<p>Regeringens uppdrag till Livsmedelsverket var tydligt: kostråden skulle beakta Sveriges förmåga att försörja befolkningen i kris och krig. Det livsmedelsstrategiska målet var att öka vår produktion, inte minska den. I stället får kostråden motsatt effekt, vilket Livsmedelsverket inte lyckats synliggöra.</p>
<h2>Klimatpolitiska rådets stöd till Livsmedelsverkets kostråd</h2>
<p>Varför har inte Livsmedelsverket tidigare behövt förtydliga målkonflikterna som de uppdaterade kostråden leder till? En delförklaring är att man delar synsätt, slutsatser och intressen med den forskarkår som idag utgör det Klimatpolitiska rådet.</p>
<p>I sin rapport från i mars 2025 riktar Klimatpolitiska rådet in sig på jordbrukssektorn.<sup>10</sup> De menar att det avgörande är att Sverige sänker både produktionen och konsumtionen av mjölk och kött från nötkreatur, får, vilt och renar. Varken Livsmedelsverket eller Klimatpolitiska rådet har försökt att sätta det svenska jordbruket och kosthållet i sitt lokala sammanhang vad gäller dess samtid eller historia.<sup>11</sup></p>
<p>Med en sådan grund kan vi förklara varför den nordliga kosten skiljer sig från många andra platser i världen, liksom varför boskapsskötsel varit central för jordbruket i Central- och Nordeuropa. Och varför nästan 90 procent av den vuxna befolkningen i Sverige tål mjölksocker, liksom varför andelen animalier i vår kost så långt tillbaka i tiden som detta kan skattas har legat tämligen konstant, från stenåldern till nutid.</p>
<p>Den faktiska traditionen för hållbara matsystem på våra nordliga breddgrader är att integrera boskapsskötseln som en del i växtodlingen.<sup>12</sup> Så när myndigheterna nu pratar om en omställning av industrisamhället är den första frågan om man förstått på vilka sätt boskapsskötseln, särskilt mjölkproduktionen de senaste tvåhundra åren, varit en förutsättning för själva industrialiseringen, för tillväxten av den urbaniserade befolkningen och för framväxten av den nordiska välfärdsstaten.<sup>13</sup></p>
<p>Varken Livsmedelsverket eller Klimatpolitiska rådet visar någon djupare förståelse för det nordiska samhälle som de nu vill ändra kosten för. I stället vill de utan belägg påbörja ett fullskaleexperiment som ska revolutionera Sveriges kost och jordbruk.<sup>14</sup> Detta skulle radikalt bryta med de kostmönster som i en evolutionär process mejslats fram under 5 000 år, och där samspelet mellan människor och djur, kultur och odling, bitvis och under ständigt tryck testats fram i verklighetens ekosystem.</p>
<p>Vår erfarenhet, och tidigare generationers, säger att vad våra klimatpolitiska forskarkollegor föreslår ej fungerar.</p>
<p>Deras experiment med folkförsörjningen är inget som vare sig Sverige eller Europa i dagens geopolitiska läge har råd att prova.<a href="#_ftnref1" name="_ftn1"></a></p>
<div class="notes-wrapper"><a class="shadow-button noselect show-notes"  data-articleid="178367">  <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>Se Klimatpolitiska rådets rapport 2025, <a href="https://www.klimatpolitiskaradet.se/wp-content/uploads/2025/03/klimatpolitiskaradetsrapport2025.pdf">https://www.klimatpolitiskaradet.se/wp-content/uploads/2025/03/klimatpolitiskaradetsrapport2025.pdf</a></li>
<li>Se <em>Nya råd: Ät ännu mindre kött och undvik alkohol</em>, https://www.aftonbladet.se/nyheter/a/Xb3jEB/nya-rad-at-annu-mindre-kott-och-undvik-alkohol</li>
<li>DN Debatt (6 maj 2025): <em>Vår forskning kan inte viftas bort som åsikter</em>, https://www.dn.se/debatt/var-forskning-kan-inte-viftas-bort-som-asikter/</li>
<li>Se <em>Fördjupad konsekvensanalys av kostrådet om rött kött och chark</em>, <a href="https://www.livsmedelsverket.se/globalassets/publikationsdatabas/rapporter/2025/r-2025-fordjupad-konsekvensanalys-av-kostradet-om-rott-kott-och-chark-allt.pdf">https://www.livsmedelsverket.se/globalassets/publikationsdatabas/rapporter/2025/r-2025-fordjupad-konsekvensanalys-av-kostradet-om-rott-kott-och-chark-allt.pdf</a></li>
<li>Se <em>Livsmedelsverkets generella kostråd för den vuxna befolkningen</em>, <a href="http://www.livsmedelsverket.se/globalassets/publikationsdatabas/rapporter/2025/l-2025-nr-04-livsmedelsverkets-generella-kostrad-for-den-vuxna-befolkningen.pdf">www.livsmedelsverket.se/globalassets/publikationsdatabas/rapporter/2025/l-2025-nr-04-livsmedelsverkets-generella-kostrad-for-den-vuxna-befolkningen.pdf</a></li>
<li>Folkhälsomyndigheten och Livsmedelsverket 2024.  <em>En hållbar och hälsosam livsmedelskonsumtion: Återredovisning av regeringsuppdrag, inklusive bilagor</em>, <a href="https://www.livsmedelsverket.se/globalassets/publikationsdatabas/rapporter/2024/2024-en-hallbar-och-halsosam-livsmedelskonsumtion.pdf">https://www.livsmedelsverket.se/globalassets/publikationsdatabas/rapporter/2024/2024-en-hallbar-och-halsosam-livsmedelskonsumtion.pdf</a></li>
<li>För relevanta avsnitt från Jordbruksverkets officiella statistik, se <a href="https://jordbruksverket.se/download/18.4f9dead71770f4e9ae04a203/1742369196768/Marknadsbalans-mejeriprodukter-tga.xlsx">Mejeriprodukter – marknadsbalans</a>. Läs fliken ”mjölkekvivalenter”, och då särskilt kolumn H ”Totalkonsumtion kg/capita” — rad 50 ger data för år 2024. Värdet för cell G50 är 374,7 kg mjölkekvivalenter per person och år i totalkonsumtion. För 365 dagar ger det en konsumtion på 1 027 gram per dag. Kostrådet om 350–500 gram magra mjölkprodukter, inklusive mejeriprodukter, ger ett råd om i medel 425 gram per person och dag. Ställt mot medelkonsumtionen per dag på 1 027 gram innebär det en minskning med (1-425/1 027) * 100 = 59 procent., dvs ca 60 procent. Om vi även räknar med effekten av att bara välja magra produkter blir det en minskning med ca 70 procent.</li>
<li>Se <em>Nordic nutrition recommendations 2023: Integrating environmental aspects</em>, <a href="https://norden.diva-portal.org/smash/record.jsf?pid=diva2%3A1769986&amp;dswid=-2490">https://norden.diva-portal.org/smash/record.jsf?pid=diva2%3A1769986&amp;dswid=-2490</a>; <em>Legislative framework for sustainable food systems</em>, <a href="https://food.ec.europa.eu/horizontal-topics/farm-fork-strategy/legislative-framework_en">https://food.ec.europa.eu/horizontal-topics/farm-fork-strategy/legislative-framework_en</a></li>
<li>SAPEA. <em>A sustainable food system for the European Union</em>. Evidence Review Report no.7. Berlin: Science Advice for Policy by European Academies; 2020; se även Willett, W., Rockström, J., Loken, B., Springmann, M., Lang, T., Vermeulen, S., . . . Murray, C. J. L. (2019). <em>Food in the Anthropocene</em>: <em>The EAT &#8211; Lancet commission on healthy diets from sustainable food systems</em>. <em>Lancet</em>, 393(10170), 447-492. doi:10.1016/ S0140-6736(18)31788-4;</li>
<li>Se Klimatpolitiska rådets rapport 2025: https://www.klimatpolitiskaradet.se/wp-content/uploads/2025/03/klimatpolitiskaradetsrapport2025.pdf</li>
<li>Se exempelvis Myrdal. J. (Redaktör). <em>Det svenska jordbrukets historia</em>, fem band åren 1998–2001: <a href="https://www.ksla.se/bibliotek/fembandsverket/">https://www.ksla.se/bibliotek/fembandsverket/</a></li>
<li>Det är framförallt i extrema miljöer som nordliga breddgrader, bergstrakter och torra områden, där vanligt åkerbruk inte fungerar, som människor använt sig av boskap för att omvandla växtlighet till mat i form av kött- och mejeriprodukter. Se exempelvis: Itan Y, Jones BL, Ingram CJ, Swallow DM, Thomas MG (February 2010). <a href="https://www.ncbi.nlm.nih.gov/pmc/articles/PMC2834688"><em>A worldwide correlation of lactase persistence phenotype and genotypes</em></a>. <em>BMC Evolutionary Biology</em>. 10 (1):</li>
<li>Se Morell, M. 2022. <em>Agrar revolution: Jordbruksproduktionen i Uppsala och Västmanlands län 1750–1920</em>, <a href="https://uu.diva-portal.org/smash/get/diva2:1647144/FULLTEXT01.pdf">https://uu.diva-portal.org/smash/get/diva2:1647144/FULLTEXT01.pdf</a>; samt Myrdal. J. (Redaktör). <em>Det svenska jordbrukets historia</em>, fem band åren 1998–2001; band 3-5, https://www.ksla.se/bibliotek/fembandsverket/.</li>
<li>Se Willett, W. et al., 2019, <em>Food in the anthropocene: the EAT–Lancet Commission on healthy diets from sustainable food systems</em>, <em>Lancet</em> 393, 447–492. Den stora transformeringen av det globala matsystemet beskrivs som en nödvändig, revolutionär förändring.</li>
</ol>
</div>
</div>
<div class="author-byline">Johan Gärdebo är historiker verksam som forskare vid Uppsala universitet och Research Fellow vid University of Cambridge.</p>
<p>Stefan Hellstrand är agronom och disputerad forskare inom energi- och miljöteknik.
</p></div>
</div>
