Varför föds det så få barn i Sverige?

<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-165415"      class = "kv-pod-holder kv-player-light  lplo " data-sid="" data-eid="" data-tis="916" data-tin="1012" data-pid="165415" data-pty="SW5sw6RzdCBhcnRpa2VsIChTYW1ow6RsbGUp" data-pna="VmFyZsO2ciBmw7ZkcyBkZXQgc8OlIGbDpSBiYXJuIGkgU3ZlcmlnZT8=" data-acurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2UvaW5sYXN0YXRleHRlci82LTI5LXZhcmZvci1mb2RzLWRldC1zYS1mYS1iYXJuLWktc3ZlcmlnZV8ubXAz" data-psurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2Uva2p4ajYzeWRkZXEydmgvNi0yOS12YXJmb3ItZm9kcy1kZXQtc2EtZmEtYmFybi1pLXN2ZXJpZ2VfLm1wMw==">  <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%2Fvarfor-fods-det-sa-fa-barn-i-sverige%2F&amp;t=Varf%C3%B6r+f%C3%B6ds+det+s%C3%A5+f%C3%A5+barn+i+Sverige%3F"    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=Varf%C3%B6r+f%C3%B6ds+det+s%C3%A5+f%C3%A5+barn+i+Sverige%3F+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fvarfor-fods-det-sa-fa-barn-i-sverige%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%2Fvarfor-fods-det-sa-fa-barn-i-sverige%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Varför föds det så få barn i Sverige?&body=https://kvartal.se/artiklar/varfor-fods-det-sa-fa-barn-i-sverige/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/165415/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/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> | 4 februari 2025<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%2Fvarfor-fods-det-sa-fa-barn-i-sverige%2F&amp;t=Varf%C3%B6r+f%C3%B6ds+det+s%C3%A5+f%C3%A5+barn+i+Sverige%3F"    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=Varf%C3%B6r+f%C3%B6ds+det+s%C3%A5+f%C3%A5+barn+i+Sverige%3F+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fvarfor-fods-det-sa-fa-barn-i-sverige%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%2Fvarfor-fods-det-sa-fa-barn-i-sverige%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Varför föds det så få barn i Sverige?&body=https://kvartal.se/artiklar/varfor-fods-det-sa-fa-barn-i-sverige/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/165415/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/varfor-fods-det-sa-fa-barn-i-sverige/?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 11 min</span></a><a href   = "https://kvartal.se/skarmlasarvanlig/d0607fdf-851d-4d29-ac3d-e916c4d98cb0"    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-165415">  <div class="in-short-inner">    <span class="close_button close-in-short in-short-toggle" data-articleid = "165415"></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 nästan tio år sedan började <strong>Lena Lundkvist</strong> på SCB bli fundersam. Hon är demograf och expert på statistiken över barnafödande och befolkningsframskrivningar i Sverige.</p>
</div>
<div class="rest-of-article ">
<p>Kurvan över barnafödande såg inte längre ut som den brukade. I Sverige följer i regel nativiteten de ekonomiska konjunkturerna. Bra tider – många barn. Dåliga tider – färre barn.</p>
<p>– Så vi tänkte att det borde väl vända. Men det händer inte, berättar hon.</p>
<p>Antalet födda barn i Sverige <a href="https://www.scb.se/pressmeddelande/historiskt-lagt-barnafodande-och-lagsta-folkokningen-pa-22-ar/">minskade</a> alltså för några år sedan, men mäter man antal barn per kvinna, TFR (<em>total fertility rate</em>), som är det vanligaste måttet, så har det i princip minskat sedan 2010 ungefär, säger Lena Lundkvist.</p>
<p>År 2024 års siffror ser ut att bli som 2023 års, det vill säga 1,44 barn per kvinna – den lägst uppmätta siffran så länge vi har haft statistik, och det har vi haft sedan mitten av 1700-talet. Som många vet innebär en nativitet på 2,1 barn per kvinna att befolkningsmängden är stabil. Är den högre, ökar den – är den mindre, minskar den. Sedan kan förstås in- och utvandring påverka befolkningstalet i ett land.</p>
<p>Barnafödandet har minskat i alla utbildningsgrupper och i hela Sverige, både bland de med svensk och utländsk bakgrund, berättar Lena Lundkvist.</p>
<figure id="attachment_165511" aria-describedby="caption-attachment-165511" style="width: 1252px" class="wp-caption alignnone"><img fetchpriority="high" decoding="async" class="wp-image-165511 size-full" src="https://kvartal.se/wp-content/uploads/2025/02/TFR.png" alt="Kvartal" width="1252" height="826" data-wp-pid="165511" srcset="https://kvartal.se/wp-content/uploads/2025/02/TFR.png 1252w, https://kvartal.se/wp-content/uploads/2025/02/TFR-300x198.png 300w, https://kvartal.se/wp-content/uploads/2025/02/TFR-768x507.png 768w, https://kvartal.se/wp-content/uploads/2025/02/TFR-600x396.png 600w" sizes="(max-width: 1252px) 100vw, 1252px" /><figcaption id="caption-attachment-165511" class="wp-caption-text"><em>Barn per kvinna i Sverige de senaste 100 åren. Källa: SCB</em></figcaption></figure>
<p>– Under pandemin avstannade nedgången, och då tänkte vi att nu vänder det, fortsätter Lena Lundkvist. Men så blev det inte.</p>
<p>Nedgången på senare år är svår att förklara.</p>
<p>– Det som brukar diskuteras, men som inte går att bevisa, är de sociala medierna som slog igenom på 2010-talet. Man kan se hur andra människor reser och har den perfekta bostaden och gör en massa saker. Många vill hinna med så mycket innan familjelivet. Kanske spelar det roll, säger Lena Lundkvist.</p>
<h2>Barn allt senare i livet</h2>
<p>Man kan i SCB:s statistik se hur olika generationer av kvinnor – siffrorna handlar om just kvinnorna – skaffar barn allt senare, årskull för årskull. De som är födda år 2000 och som nu är i 25-årsåldern får det första barnet senare än alla andra generationer.</p>
<p>– Det som händer när man skjuter upp det första barnet är att man inte hinner med så många barn till, berättar Lena Lundkvist. Det är färre och färre som får fyra eller fler barn. Även trebarnsmammorna har minskat över tid. Medan de barnlösa och enbarnsmammorna blir fler.</p>
<p>Sveriges nordiska grannländer uppvisar en likartad utveckling. Finland har lägst födelsetal per kvinna, och på Island föds flest barn per kvinna. Men skillnaderna är marginella – i alla nordiska länder föds runt 1,5 barn per kvinna. Och tendensen är i nuläget sjunkande i alla fem länderna.</p>
<figure id="attachment_165621" aria-describedby="caption-attachment-165621" style="width: 1203px" class="wp-caption alignnone"><img decoding="async" class="wp-image-165621 size-full" src="https://kvartal.se/wp-content/uploads/2025/02/SCB2.png" alt="kvartal" width="1203" height="708" data-wp-pid="165621" srcset="https://kvartal.se/wp-content/uploads/2025/02/SCB2.png 1203w, https://kvartal.se/wp-content/uploads/2025/02/SCB2-300x177.png 300w, https://kvartal.se/wp-content/uploads/2025/02/SCB2-768x452.png 768w, https://kvartal.se/wp-content/uploads/2025/02/SCB2-600x353.png 600w" sizes="(max-width: 1203px) 100vw, 1203px" /><figcaption id="caption-attachment-165621" class="wp-caption-text"><em>Andel kvinnor inom en årskull med minst ett barn, med ålder på den liggande axeln. Man ser till exempel att bland kvinnor i Sverige födda 1955 hade cirka 45 procent fått sitt första barn vid 25 års ålder. Men bland kvinnor födda 1980 hade cirka 20 procent fått sitt första barn vid 25 års ålder. Källa: SCB</em></figcaption></figure>
<p>Bland forskare är man inte helt på det klara <em>varför</em> vi föder allt färre barn. <strong>Gunnar Andersson</strong> är professor i demografi vid Stockholms universitet och han har deltagit i flera <a href="https://www.su.se/profiles/gande-1.184639?open-collapse-boxes=research-projects">forskningsprojekt</a> om barnafödande. Han har mycket att göra och låter sig intervjuas via e-post.</p>
<p><strong>Varför föds det så få barn i Sverige?</strong></p>
<p>Utvecklingen är inget som är specifikt för Sverige men hänger samman med att barnlösa samboende par inte bestämmer sig för att gå vidare i familjebildningen genom att bli föräldrar. Det är lite svårt att säga exakt varför det är så men det hänger samman med subjektiva förändringsfaktorer som verkar på global nivå.</p>
<p><strong>Ska man vara bekymrad över detta faktum? </strong></p>
<p>Inte på kort sikt, men om utvecklingen håller i sig så får det stora effekter på åldersstrukturer, med väldigt få yngre som ska försörja allt fler äldre. På individnivå kan det också vara ett problem om slutresultatet blir att personer som egentligen skulle vilja ha blivit föräldrar i stället förblir barnlösa.</p>
<p><strong>Har Sverige lägre födelsetal än andra, jämförbara länder?</strong></p>
<p>Tidigare har det varit så att de nordiska länderna legat i topp om man jämför med andra utvecklade länder. Nu är det inte lika tydligt att så är fallet men det finns fortfarande ett stort antal länder, till exempel i Sydeuropa och Östasien, som har betydligt lägre <a href="https://www.gapminder.org/tools/#$model$markers$bar$encoding$x$data$concept=children_per_woman_total_fertility&amp;source=fasttrack&amp;space@=geo&amp;=time;;&amp;scale$domain:null&amp;type:null&amp;zoomed:null;;;;;;&amp;chart-type=barrank&amp;url=v2">fruktsamhetsnivåer</a> än Sverige.</p>
<p><strong>Kommer det att vända uppåt igen, tror du? Och när, ungefär, i så fall?</strong></p>
<p>Det är svårt att sia om, eftersom själva nedgången varit så oväntad och delvis svårförklarad. Men det ser faktiskt ut som att fruktsamhetstalen just nu håller på att plana ut och man kan kanske vänta sig en viss återhämtning framöver. Enligt SCB:s prognos, som bygger på analyser av den underliggande strukturen på fruktsamhetstalen, är det dock inte troligt att nivåerna på barnafödandet kommer att återgå till de förhållanden som gällde innan nedgången.</p>
<p><strong>Kan man säga något om vilka grupper som tenderar att få flest eller minst antal barn i Sverige (geografi, socioekonomi, demografi med mera)? </strong></p>
<p>Ja, det kan man, och det som är anmärkningsvärt i Sverige är att det är så stora likheter i barnafödandet mellan olika grupper i landet, både när det gäller utbildningsnivå, bosättningsort i landet och utrikes bakgrund.</p>
<p><strong>Har du som forskare i demografi något råd till befolkning respektive politiker om hur vi ska öka barnafödandet? </strong></p>
<p>Nej, det är lite knepigt. Den underliggande samhällsmodellen i Sverige och de övriga nordiska länderna är faktiskt väldigt förmånlig när det gäller möjligheterna att kombinera olika aktiviteter i livet, såsom förvärvsarbete och föräldraskap. Förbättringspotentialen är inte så stor.</p>
<h2>En global trend</h2>
<p><a href="https://ourworldindata.org/grapher/children-per-woman-un?tab=line&amp;time=1950..latest&amp;country=OWID_WRL~SWE">Utvecklingen i världen</a> i övrigt är som sagt liknande. Barnafödandet sjunker generellt – det är en <a href="https://ourworldindata.org/fertility-rate">global megatrend</a>. För 50 år sedan föddes det drygt fyra barn per kvinna. Idag är siffran drygt två barn per kvinna. I takt med att vi <a href="https://www.gapminder.org/tools/#$model$markers$bubble$encoding$y$data$concept=children_per_woman_total_fertility&amp;source=fasttrack&amp;space@=geo&amp;=time;;&amp;scale$domain:null&amp;zoomed:null&amp;type:null;;&amp;x$data$concept=lex&amp;source=fasttrack&amp;space@=geo&amp;=time;;&amp;scale$domain:null&amp;zoomed:null&amp;type:null;;&amp;frame$value=2023;;;;;&amp;chart-type=bubbles&amp;url=v2">lever längre liv föder vi allt färre barn</a> – sambandet är mycket tydligt. Även korrelationen mellan kvinnors växande utbildningsnivå och minskat barnafödande är <a href="https://ourworldindata.org/grapher/womens-educational-attainment-vs-fertility?time=earliest..2020">mycket stark</a> i så gott som alla länder.</p>
<p>En som länge intresserat sig för denna fråga är <strong>Tomas Sobotka</strong>, som är <a href="https://www.wittgensteincentre.org/en/staff/member/sobotka.htm">forskare</a> i demografi vid <em>Wittgenstein Center for Demography and Global Human Capital</em> i Österrike. Han menar att ekonomin har en stor påverkan på det minskande barnafödandet i Västvärlden.</p>
<p>– Sverige är inte ensamt om ett rekordlågt barnafödande, säger han. Man ser rubriker om detta titt som tätt även här. Många andra länder har en liknande utveckling.</p>
<p>Österrike har lite lägre födelsetal än Sverige, drygt 1,3 barn per kvinna, och även de har <a href="https://ourworldindata.org/grapher/children-per-woman-un?tab=line&amp;time=1950..latest&amp;country=OWID_WRL~AUT">rekordlågt</a> barnafödande enligt senaste data. Båda länderna ligger nära det <a href="https://www.gapminder.org/tools/#$model$markers$line$data$filter$dimensions$geo$/$or@$geo$/$in@=aut&amp;=europe&amp;=swe;;;;;;;;&amp;encoding$y$data$concept=children_per_woman_total_fertility&amp;source=fasttrack&amp;space@=geo&amp;=time;;&amp;scale$type:null&amp;domain:null&amp;zoomed:null;;;;;;&amp;chart-type=linechart&amp;url=v2">europeiska snittet</a> på drygt 1,4 barn per kvinna.</p>
<figure id="attachment_165645" aria-describedby="caption-attachment-165645" style="width: 1200px" class="wp-caption alignnone"><img decoding="async" class="wp-image-165645 size-full" src="https://kvartal.se/wp-content/uploads/2025/02/Barn.jpg" alt="" width="1200" height="675" data-wp-pid="165598" srcset="https://kvartal.se/wp-content/uploads/2025/02/Barn.jpg 1200w, https://kvartal.se/wp-content/uploads/2025/02/Barn-300x169.jpg 300w, https://kvartal.se/wp-content/uploads/2025/02/Barn-768x432.jpg 768w, https://kvartal.se/wp-content/uploads/2025/02/Barn-926x521.jpg 926w, https://kvartal.se/wp-content/uploads/2025/02/Barn-600x338.jpg 600w" sizes="(max-width: 1200px) 100vw, 1200px" /><figcaption id="caption-attachment-165645" class="wp-caption-text"><em>Barn i Seoul. I Sydkorea föds det färre än 0,8 barn per kvinna. Det är den lägsta siffran i världen. Somalia har den högsta siffran i världen, 6,1 barn per kvinna. Foto: Ahn Young-Joo/TT</em></figcaption></figure>
<p>– Det vi ser nu är en accelerering av den globala trenden mot mindre familjer, säger han. Vi har sett upp- och nedgångar – särskilt i Sverige – men den övergripande trenden är stark; kvinnor föder färre barn. Vi ser till exempel att kvinnor blir mammor allt senare i livet och det betyder såklart färre stora familjer. Och fler som blir barnlösa.</p>
<blockquote><p>I många länder sker sexdebuten senare än vad den gjorde för några decennier sedan.</p></blockquote>
<p>Fram till nyligen var tvåbarnsnormen stark. Många önskade sig just två barn. Men i opinionsundersökningar där man frågar unga idag om deras familjeplaner säger allt fler att de vill ha ett barn eller vara barnlösa eller barnfria, berättar Tomas Sobotka. Ungefär hälften av 20–24-åringarna i Österrike ger numera oklara svar om önskemål om framtida familjebildning.</p>
<p>– Men det mest intressanta är att många unga inte funderar på föräldraskap överhuvudtaget, säger Tomas Sobotka. Vi får ofta svar som ”jag vet inte” – så var det inte för ett par decennier sedan.</p>
<h2>Barn kostar pengar</h2>
<p>De senaste 15 årens nedgång i barnafödande i den rika delen av världen – Västvärlden och Östasien – har delvis rent objektiva orsaker. Det handlar om ekonomi, säger Tomas Sobotka. I många länder har de unga en stagnerande ekonomi, och det finns risk att dagens unga generation inte får det lika bra som sina föräldrar. Sånt påverkar både önskan och förmåga att bilda familj.</p>
<p>– Många vill ha trygghet innan de bildar familj – de vill bo bra, ha bil och en ekonomisk buffert. Barn kostar mycket pengar, säger Tomas Sobotka. Det finns skillnader mellan länder, men detta är ett övergripande problem.</p>
<p>Det finns även andra skäl. Till exempel den förlängda ungdomsperioden och att många skjuter på familjebildandet. Då kan man drabbas av ofrivillig barnlöshet på grund av ålder. Dessutom, menar Tomas Sobotka, tar det ofta längre tid att hitta en partner idag. I många länder sker sexdebuten senare än vad den gjorde för några decennier sedan.</p>
<p>– Färre unga dejtar och har stabil relation, säger han.</p>
<p>Många funderar på om sociala medier och skärmtid spelar in. Barnafödandet har minskat ungefär samtidigt som allt detta har börjat prägla våra liv.</p>
<p>– Ja, även vi demografer pratar om detta, säger Tomas Sobotka. Men vi har inga statistiska belägg för det.</p>
<p>Men han ser flera exempel på hur all skärmtid påverkar oss. Många ser klipp på söta katter på nätet – men inte på söta bäbisar. Sociala medier kan även medföra att normer formas på olika sätt i olika generationer, och samtidigt leder all skärmtid till att många träffas mindre i det verkliga livet. Det leder varken till kärleksrelationer eller fler barn – man måste träffas fysiskt för att det ska bli barn gjorda.</p>
<p>– Många av oss har en tydlig känsla av att skärmar och sociala medier kan påverka barnafödandet – men det är svårt att vetenskapligt slå fast detta, säger Tomas Sobotka.</p>
<p>Framtiden kommer av allt att döma fortsatt präglas av låga födelsetal, menar Tomas Sobotka.</p>
<p>– Alla kriser vi sett på senare år, covid, inflation, krig och instabilitet i världen, påverkar sannolikt också många yngre människor. Kanske vill man inte sätta barn till världen när pessimismen är stor.</p>
<p>Många ser ändå barn som livets yttersta mening – att ta människosläktet vidare. Är det inte så längre?</p>
<p>– Jag tror att olika generationer ser olika på saken. Och majoriteten av oss får fortfarande barn, trots allt, säger Tomas Sobotka.</p>
<h2>Det kommer att vända</h2>
<p>Så teorierna kring detta varierar. Men Lena Lundkvist på SCB är säker på sin sak vad gäller Sverige i alla fall.</p>
<p>– Det <em>kommer</em> att vända någon gång. Jag vet inte när. Men det kommer att vända, för det har det alltid gjort.</p>
<p><strong>Kan det dystra världsläget spela roll?</strong></p>
<p>– Kanske. Men vi noterade nedgången i barnafödandet redan innan kriget i Ukraina och pandemin. Jag tror snarare att det handlar om att vi vill göra så mycket innan vi blir vuxna. Då kommer barnafödandet i kläm.<br />
<div class = "kv-cruta closed grey cr-round "      id    = "cruta-eaRyvdkIUO"></p>
<h2>Enkät: Varför tror du att det föds så få barn i Sverige?</h2>
<hr style="border-top: 1px solid #ddd;" />
<p>&nbsp;</p>
<p><img decoding="async" class="wp-image-165667 size-full" src="https://kvartal.se/wp-content/uploads/2025/02/Johanna-1.jpg" alt="" width="1200" height="675" data-wp-pid="165639" srcset="https://kvartal.se/wp-content/uploads/2025/02/Johanna-1.jpg 1200w, https://kvartal.se/wp-content/uploads/2025/02/Johanna-1-300x169.jpg 300w, https://kvartal.se/wp-content/uploads/2025/02/Johanna-1-768x432.jpg 768w, https://kvartal.se/wp-content/uploads/2025/02/Johanna-1-926x521.jpg 926w, https://kvartal.se/wp-content/uploads/2025/02/Johanna-1-600x338.jpg 600w" sizes="(max-width: 1200px) 100vw, 1200px" /><em style="font-family: 'Open sans'; font-size: 14px; color: #666;">Foto: Privat</em></p>
<p><strong>Johanna de Abreu, 38 år, ansvarig för sociala medier och community på Kvartal samt mamma till två barn, ett bonusbarn och har ett till på väg</strong></p>
<p>Jag tror att det beror på flera faktorer, kanske främst egna krav och föreställningar. Många har nog en idé om att man ska vara helt redo när man väl bildar familj; man ska ha utbildat sig, rest, hittat sitt livs kärlek, gift sig, köpt hus och gärna två bilar, ha god ekonomi, hittat en plats i sitt yrkesverksamma liv där man trivs och etablerat sig så att man känner att man har ro att vara föräldraledig i ett år per barn. Detta tar tid. Många blir allt äldre innan man får sitt första barn och då kommer även det biologiska in; allt fler får svårt att få barn när man väl känner sig redo.</p>
<hr style="border-top: 1px solid #ddd;" />
<p>&nbsp;</p>
<p><img decoding="async" class="wp-image-165635 size-full" src="https://kvartal.se/wp-content/uploads/2025/02/Camilla.jpg" alt="" width="1200" height="675" data-wp-pid="165567" srcset="https://kvartal.se/wp-content/uploads/2025/02/Camilla.jpg 1200w, https://kvartal.se/wp-content/uploads/2025/02/Camilla-300x169.jpg 300w, https://kvartal.se/wp-content/uploads/2025/02/Camilla-768x432.jpg 768w, https://kvartal.se/wp-content/uploads/2025/02/Camilla-926x521.jpg 926w, https://kvartal.se/wp-content/uploads/2025/02/Camilla-600x338.jpg 600w" sizes="(max-width: 1200px) 100vw, 1200px" /><em style="font-family: 'Open sans'; font-size: 14px; color: #666;">Foto: Jonas Borg</em></p>
<p><strong>Camilla Bergman, 41 år, entreprenör och mamma till två barn</strong></p>
<p>Jag tror att det är en kombination av sämre ekonomiska tider, att man väntar med att skaffa barn och att folk har mindre sex på grund av mobilsurfande. Folk ligger där och scrollar i sängen i stället för att ha kul med varandra. Sen är det säkert en och annan som väljer bort barn på grund av oroliga tider – krig och klimatkris – men det har jag svårt att se skulle slå på en större skala.</p>
<hr style="border-top: 1px solid #ddd;" />
<p>&nbsp;</p>
<p><img decoding="async" class="wp-image-165641 size-full" src="https://kvartal.se/wp-content/uploads/2025/02/Ulrika.jpg" alt="" width="1200" height="675" data-wp-pid="165625" srcset="https://kvartal.se/wp-content/uploads/2025/02/Ulrika.jpg 1200w, https://kvartal.se/wp-content/uploads/2025/02/Ulrika-300x169.jpg 300w, https://kvartal.se/wp-content/uploads/2025/02/Ulrika-768x432.jpg 768w, https://kvartal.se/wp-content/uploads/2025/02/Ulrika-926x521.jpg 926w, https://kvartal.se/wp-content/uploads/2025/02/Ulrika-600x338.jpg 600w" sizes="(max-width: 1200px) 100vw, 1200px" /><em style="font-family: 'Open sans'; font-size: 14px; color: #666;">Foto: Privat</em></p>
<div>
<p><strong>Ulrika Hellberg, 36 år, skattejurist och mamma till ett barn</strong></p>
<p>Jag tror många kvinnor känner att det är svårt att kombinera barn och karriär, kanske för att det bär emot att låta yrkeslivet stå tillbaka, ens under några år. Det upplevs nog som omodernt och bakåtsträvande. Många väntar även länge med att skaffa första barnet för att hinna göra karriär, och det visar sig sedan vara svårt eller omöjligt att få barn. Sen har nog den rådande dejtingkulturen också betydelse, där många fastnar i Tinderträsket.</p>
<hr style="border-top: 1px solid #ddd;" />
</div>
<p>&nbsp;</p>
<p><img decoding="async" class="wp-image-165636 size-full" src="https://kvartal.se/wp-content/uploads/2025/02/Martina.jpg" alt="" width="1200" height="675" data-wp-pid="165636" srcset="https://kvartal.se/wp-content/uploads/2025/02/Martina.jpg 1200w, https://kvartal.se/wp-content/uploads/2025/02/Martina-300x169.jpg 300w, https://kvartal.se/wp-content/uploads/2025/02/Martina-768x432.jpg 768w, https://kvartal.se/wp-content/uploads/2025/02/Martina-926x521.jpg 926w, https://kvartal.se/wp-content/uploads/2025/02/Martina-600x338.jpg 600w" sizes="(max-width: 1200px) 100vw, 1200px" /><em style="font-family: 'Open sans'; font-size: 14px; color: #666;">Foto: Privat</em></p>
<p><strong>Martina Rünell, 31 år, verksamhetsutvecklare på Migrationsverket och mamma till ett barn<br />
</strong></p>
<p>Jag tror att det föds färre barn för att kvinnor har fått fler intressen, bättre ekonomiska förutsättningar och större inflytande. Och det går inte att sticka under stol med att barnafödande varken gynnar privatekonomin eller ens övriga intressen. Jag upplever också att det skett en förändring i kulturella värderingar som kanske också spelar roll; individen före familj och samhälle.</p>
<p></div></p>
<div class="author-byline">Henrik Höjer är Kvartals vetenskapsredaktör. Han är även historiker och författare.
</div>
</div>
