Kungen av långkörning i norr

Snömängden i södra Sverige har väl aldrig varit mindre. Längtan efter att få skidra ut på en frusen älv och nyfikenheten kring hur nya Audi e-Tron 50 quattro, Kia e-Niro och Nissan Leaf e+ presterar i kyla gjorde att vi lastade in skidorna och drog norrut. Må bästa elbil vinna. Text: Lotta Hedin, Fredrik Sandberg […]


<p><strong>Snömängden i södra Sverige har väl aldrig varit mindre. Längtan efter att få skidra ut på en frusen älv och nyfikenheten kring hur nya Audi e-Tron 50 quattro, Kia e-Niro och Nissan Leaf e+ presterar i kyla gjorde att vi lastade in skidorna och drog norrut. Må bästa elbil vinna.</strong><div id="elbilen_panorama-1"></div><script>lwhb.cmd.push(function() {lwhb.loadAd({tagId: "elbilen_panorama-1"});});</script><div id="elbilen_mobil-1"></div><script>lwhb.cmd.push(function() {lwhb.loadAd({tagId: "elbilen_mobil-1"});});</script></p>



<pre class="wp-block-preformatted">Text: Lotta Hedin, Fredrik Sandberg och Ida Karlsson | Foto: Fredrik Broman.
</pre>



<p class="has-drop-cap"><strong>N</strong>är Elbilen för drygt ett år sedan lät fyra bilar mäta sig mot varandra på sträckan Haparanda–Ystad, utmärkte sig Kia e-Niro som snålast. Tesla Model S kom fram först till målet. Men dryga halvmiljonen billigare Kia e-Niro, med sitt betydligt mindre batteri, imponerade.</p>



<p>Sedan dess har det hänt en del i e-Niros pris- och räckviddssegment. Konkurrensen har tätnat: Nissan Leaf har kommit med en uppgraderad, piggare version med nästan samma batteri-</p>



<p>kapacitet (62 KWh) och räckvidd som är i närheten av e-Niro. Audi e-Tron har just släppt en billigare variant, med mindre batterikapacitet (71 kWh) med liknande räckvidd.</p>



<p>Frågan är hur de två nykomlingarna i mellanklassen står sig mot e-Niron i en jämförelse?</p>



<figure class="wp-block-image size-large"><img fetchpriority="high" decoding="async" width="1030" height="687" src="https://elbilen.se/wp-content/uploads/2020/06/93A2711-1030x687.jpg" alt="" class="wp-image-15473" srcset="https://elbilen.se/wp-content/uploads/2020/06/93A2711-1030x687.jpg 1030w, https://elbilen.se/wp-content/uploads/2020/06/93A2711-300x200.jpg 300w, https://elbilen.se/wp-content/uploads/2020/06/93A2711-768x512.jpg 768w, https://elbilen.se/wp-content/uploads/2020/06/93A2711-1536x1024.jpg 1536w, https://elbilen.se/wp-content/uploads/2020/06/93A2711.jpg 1600w" sizes="(max-width: 1030px) 100vw, 1030px" /><figcaption>&nbsp;Stadigt grepp om ratten i slirigt vinterföre.&nbsp;<br></figcaption></figure>



<p>Vi bestämde oss för att testa bilarna i riktigt vinterföre, med långa körsträckor och upprepad laddning i rejäla minusgrader. Men för att få uppleva ordentlig vinter detta rekordvarma år var vi tvungna att köra långt: hundra mil, närmare bestämt, rakt norrut.</p>



<p>Vi lämnade Stockholm klockan tio i nio en fredagsmorgon i mitten av februari. Vädret var milt. 8 grader varmt och klarblå himmel.</p>



<p>Snart växte avståndet mellan bilarna eftersom behovet av laddstopp varierade stort.</p>



<p>När det var dags för hemresa bytte vi bilar med varandra. Det minst sagt svårhanterliga vädret som hade dragit in över Norrland gjorde att vi valde att åka tillbaka samma väg, och inte via de mindre vägarna i inlandet som vi först planerat. Vi delade också upp sträckan på hemresan och gjorde en övernattning i Örnsköldsvik.</p>



<p style="color:#20bdc4" class="has-text-color has-text-align-center">KIA E-NIRO</p>



<p><strong>Stockholm–Niemisel. Förare: Lotta Hedin.</strong></p>



<p>Med 100 mils körning framför mig bestämde jag mig för en ekonomisk körstil. Jag valde Eco-läget och satte farthållaren på max 100 kilometer i timmen, som jag sedan bara överskred vid omkörningar när det var nödvändigt.&nbsp;</p>



<p>Efter 30 mil, utanför Hudiksvall, tog jag det första laddstoppet. Marginalen var god – jag hade fortfarande 23 procent kvar i batteriet när jag kopplade i handsken. En timma senare, med en sorgligt saggig men mättande vägkrogspyttipanna i magen, körde jag vidare. Jag fortsatte genom Medelpad och Ångermanland med nästan samma låga energiförbrukning: snittet låg på 17,2 kWH/100 km, trots att temperaturen ute sjönk allt mer. Först i Nordmaling, efter ytterligare 29 mil, tog jag laddstopp nummer två. Då var batteristapeln nere på rött – bara 6 procent kvar och 5 grader kallt ute.&nbsp;</p>



<p>Vid det här laget hade jag redan en lista i mitt huvud med plus och minus för e-Niron:</p>



<div class="wp-block-media-text alignwide is-stacked-on-mobile"><figure class="wp-block-media-text__media"><img decoding="async" width="1030" height="655" src="https://elbilen.se/wp-content/uploads/2020/06/93A2739_korr-1030x655.jpg" alt="" class="wp-image-15474" srcset="https://elbilen.se/wp-content/uploads/2020/06/93A2739_korr-1030x655.jpg 1030w, https://elbilen.se/wp-content/uploads/2020/06/93A2739_korr-300x191.jpg 300w, https://elbilen.se/wp-content/uploads/2020/06/93A2739_korr-768x489.jpg 768w, https://elbilen.se/wp-content/uploads/2020/06/93A2739_korr-1536x977.jpg 1536w, https://elbilen.se/wp-content/uploads/2020/06/93A2739_korr.jpg 1600w" sizes="(max-width: 1030px) 100vw, 1030px" /></figure><div class="wp-block-media-text__content">
<p>Den största fördelen är förstås bilens snålhet och långa räckvidd. När jag nu körde vidare mot Skellefteå låg jag långt före kollegorna i de andra bilarna, som behövde stanna och ladda oftare. Jag kunde också konstatera att jag trivdes mycket bra på förarplatsen, komforten i e-Niron är hög och jag gillar den höga sittpositionen och goda sikten.&nbsp;</p>
</div></div>



<p>På minussidan då? På väg genom Örnsköldsvik började bilen plötsligt pipa och varna för att laddluckan var öppen. Jag fick svänga av i nästa rondell och kolla, och mycket riktigt hade den klickat upp av sig själv och stod på glänt.</p>



<p>Och funktionen i navigeringssystemet som ska hjälpa en att hitta laddplatser är inte direkt någon hjälp. Den föreslog att jag skulle åka långa omvägar från rutten för att ladda på klena långsamladdningsstolpar, när det fanns snabbladdare i närheten.&nbsp;</p>



<p>Tredje laddstoppet blev Skellefteå. Efter det skulle jag ha klarat mig ända fram till slutmålet, men eftersom vi bara kunde ladda en bil i taget vid stugan där vi skulle sova var det bra att inte komma fram tom. Jag toppade därför upp i Luleå och körde sedan den sista biten.&nbsp;</p>



<p>Klockan var strax före ett på natten när jag kom fram, först av alla, med hela 59 procent kvar i batteriet. Jag var trött men imponerad av bilen. Tre stopp hade räckt för att klara den långa och kalla resan. Nu blev det fyra, och gott om laddning kvar för att köra runt i snön nästa dag.</p>



<p><strong>Hemresan:</strong></p>



<p><strong>Niemisel–Örnsköldsvik. Förare: Ida Karlsson.&nbsp;</strong></p>



<p>Det är dags för mig att testa Kia e-Niro, som på resan norrut snabbt drog ifrån de andra bilarna och kom först i mål.</p>



<p>Stormen vräker in över landet och vintern visar sig från sin allra sämsta sida. Är det någon skillnad att köra elbil jämfört med fossilbil säkerhetsmässigt? Nej, egentligen inte. Snarare blir väghållningen bättre tack vare att batteriets placering ger låg tyngdpunkt.</p>



<blockquote class="wp-block-quote is-layout-flow wp-block-quote-is-layout-flow"><p>”Att ladda till 85 procent tar&nbsp; en timme och 26 minuter. Det är rätt segt.”</p></blockquote>



<p>Enda nackdelen med e-Niro som vinterbil är att den saknar fyrhjulsdrift, och med friktionsdäck blir det lite slirigt när drivsnö polerar vägbanan till skridskois. Modern teknik (förutom ESP) visar sig vara till föga hjälp när sensorerna kladdar igen och kopplar ur diverse hjälpsystem som adaptiv farthållare och parkeringssensorer.</p>



<p>På radion rapporteras det om bilolyckor i tät följd, kastvindarna byts ut mot spöregn. Vi har bestämt oss för att övernatta i Örnsköldsvik, och först överväger jag att fortsätta till Sundsvall eftersom e-Niro trots ovädret oförtrutet kämpar på utan att tappa vare sig räckvidd eller laddkapacitet. Men när mörkret lägger sig och det har spöregnat i flera timmar tröttnar jag på att kana runt på regnvåta vägbanor. Jag svänger in på Paradisgaraget i Örnsköldsvik och pluggar in laddaren så att bilen ska vara fulladdad nästa morgon då resan fortsätter mot Stockholm.&nbsp;&nbsp;</p>



<p><strong>Förare: Fredrik Sandberg. Örnsköldsvik–Stockholm.</strong></p>



<p>Jag hoppar in i Örnsköldsvik och sätter av mot Stockholm. Dit är det 54 mil. Vädret är bättre än dagen innan. Ner till Söderhamn håller sig temperaturen kring nollan. Medan Lotta och Ida i en e-Tron och Nissan Leaf mest står och laddar swishar jag förbi på motorvägen. Efter 29 mil är det dags att fylla på. Och då är inte batteriet ens tomt. Jag har 14 procent.&nbsp;</p>



<p>Att ladda till 85 procent tar en timme och 26 minuter. Det är rätt segt. Hade den laddat på 50 kW konstant hade det tagit under timmen. Men det gör den inte. Jag hinner dock ta en promenad till lunchstället och är sedan redo för avfärd. Jag kör utan problem till Stockholm och får även med en abrovink till Uppsala för ett ärende. Jag har 3,5 mils räckvidd kvar när jag anländer. Resan på 200 mil drog i snitt 1,96 kWh per mil i motorvägskörning. E-Niro är onekligen en riktigt bra bil för att ta sig långt med. Rent körmässigt är det aningen gungigt, lite oprecis styrning och slirigt på isigt underlag. Den ska få större och bättre skärm samt trefasladdning och det kommer att göra den gott.&nbsp;&nbsp;&nbsp;</p>



<blockquote class="wp-block-quote is-layout-flow wp-block-quote-is-layout-flow"><p>Stormen vräker in över landet och vintern visar sig från sin allra sämsta sida. </p></blockquote>



<p style="color:#20bdc4" class="has-text-color has-text-align-center">NISSAN LEAF</p>



<p><strong>Stockholm–Niemisel. Förare: Ida Karlsson.</strong></p>



<p>Även i mina hemtrakter, några mil norr om Östersund, har det varit skralt med snö och kyla. Det har varit tvära kast mellan tö och vargavinter, ett läge som i stort sett kan sammanfattas med ett ord: blankis.</p>



<p>Resan tog sin början i ett nollgradigt Stockholm där inte ett snökorn fanns i sikte. Vi var fast beslutna att hitta riktig vinter, således iklädda våra varmaste vintermunderingar och med bilarna fulla av vinterutrustning. Lotta hade packat sina skidor, Fredrik sin snowracer. Jag utrustades med två åkbräden, entusiastisk att hitta den där perfekta pulkabacken pudrad med nysnö.</p>



<figure class="wp-block-gallery columns-3 is-cropped wp-block-gallery-1 is-layout-flex wp-block-gallery-is-layout-flex"><ul class="blocks-gallery-grid"><li class="blocks-gallery-item"><figure><img decoding="async" width="512" height="384" src="https://elbilen.se/wp-content/uploads/2020/06/unnamed-64.jpg" alt="" data-id="15477" data-link="https://elbilen.se/?attachment_id=15477" class="wp-image-15477" srcset="https://elbilen.se/wp-content/uploads/2020/06/unnamed-64.jpg 512w, https://elbilen.se/wp-content/uploads/2020/06/unnamed-64-300x225.jpg 300w" sizes="(max-width: 512px) 100vw, 512px" /></figure></li><li class="blocks-gallery-item"><figure><img decoding="async" width="512" height="341" src="https://elbilen.se/wp-content/uploads/2020/06/unnamed-63.jpg" alt="" data-id="15478" data-link="https://elbilen.se/?attachment_id=15478" class="wp-image-15478" srcset="https://elbilen.se/wp-content/uploads/2020/06/unnamed-63.jpg 512w, https://elbilen.se/wp-content/uploads/2020/06/unnamed-63-300x200.jpg 300w" sizes="(max-width: 512px) 100vw, 512px" /></figure></li><li class="blocks-gallery-item"><figure><img decoding="async" width="384" height="512" src="https://elbilen.se/wp-content/uploads/2020/06/unnamed-62.jpg" alt="" data-id="15479" data-full-url="https://elbilen.se/wp-content/uploads/2020/06/unnamed-62.jpg" data-link="https://elbilen.se/?attachment_id=15479" class="wp-image-15479" srcset="https://elbilen.se/wp-content/uploads/2020/06/unnamed-62.jpg 384w, https://elbilen.se/wp-content/uploads/2020/06/unnamed-62-225x300.jpg 225w" sizes="(max-width: 384px) 100vw, 384px" /></figure></li></ul><figcaption class="blocks-gallery-caption"><strong>Frostiga temperaturer ger långa laddtider. Dessutom krävs att bilarna laddades upp ordentligt för att klara minusgraderna. NIssan Leaf i bilden längst till höger krävde sin paus. Så även Audi e-Tron, till vänster.</strong></figcaption></figure>



<p>Det har tidigare rapporterats att Nissan Leaf varit besvärlig på långresor, mycket på grund av att batteripacket saknar kylning. Det innebär att både laddhastighet och räckvidd påverkas negativt när man utsätter bilen för långa körsträckor och upprepade laddningar på kort tid.&nbsp;</p>



<blockquote class="wp-block-quote is-layout-flow wp-block-quote-is-layout-flow"><p>”Körmässigt har Leaf lite grand överlevt sig själv. Bilen ger ingen direkt körglädje.”</p></blockquote>



<p>Sist jag gjorde ett långtest på vintern körde jag Haparanda – Ystad med Jaguar I-Pace och jobbade upp en ganska stor tålamodsbuffert. Jaggan visade sig ha orimligt kort räckvidd och lång laddtid vid minusgrader, och för en Jaguar I-Pace kan man nästan köpa en ny Nissan Leaf vid varje laddstopp. Det visade sig också vara lite problematisk att köra tre elbilar med liknande räckvidd i karavan. Eller rättare sagt: det finns för få snabbladdare och för långsamma snabbladdare. För Nissan Leaf innebar detta lite för korta körsträckor och för många laddstopp. Räckvidden gick inte att utnyttja maximalt alla gånger eftersom det inte är hållbart att stå i kö vid snabbladdarna. Detta hände två gånger under resan, både i Sundsvall och Örnsköldsvik där det visade sig att Audi e-Tron hunnit före mig och att Fredrik satt i lugn och ro och åt en hamburgare någonstans. Dock tar det kortare tid att ladda med mindre batterier. På slutet, då jag började bli lite trött och otålig, laddade jag bara så pass mycket att jag tog mig till nästa laddare, vilket gick ganska fort. Med det kan det också tilläggas att räckviddsberäkningen faktiskt kändes ganska realistisk även vid minusgrader och inga galopperande glädjekalkyler med inbyggd räckviddsångest. Jag behövde inte ens använda Eco + läget, en funktion som dessutom är en styggelse för bilar i den här prisklassen.&nbsp;</p>



<figure class="wp-block-image size-large"><img decoding="async" width="1030" height="687" src="https://elbilen.se/wp-content/uploads/2020/06/93A2790-1030x687.jpg" alt="" class="wp-image-15488" srcset="https://elbilen.se/wp-content/uploads/2020/06/93A2790-1030x687.jpg 1030w, https://elbilen.se/wp-content/uploads/2020/06/93A2790-300x200.jpg 300w, https://elbilen.se/wp-content/uploads/2020/06/93A2790-768x512.jpg 768w, https://elbilen.se/wp-content/uploads/2020/06/93A2790-1536x1024.jpg 1536w, https://elbilen.se/wp-content/uploads/2020/06/93A2790.jpg 1600w" sizes="(max-width: 1030px) 100vw, 1030px" /><figcaption>Vi laddade Nissan Leaf i över 20 timmar. Med bilen påslagen över natten. Det gav 7 procents laddning.</figcaption></figure>



<p>Det bör dock finnas ett utrymme för oförutsedda händelser. Vid sista laddstoppet, HPC-laddaren i Piteå, som inte visade sig vara särskilt supersnabb, bestämde vi oss unisont för att det smartaste skulle vara att ladda så pass att jag tog mig till Niemisel och sedan ladda i ett vanligt vägguttag under natten. Lotta och Fredrik hade gått och lagt sig när jag kom fram. Trött kunde jag konstatera att vi i alla fall hade hittat den riktiga vintern; det var minus 20 grader och snålblåst. Vägguttaget var dessvärre upptaget av värmepumpen och att dra ut den skulle väl innebära avsked, allra minst. Det fanns ett trefasuttag, dock ingen passande laddsladd till Leaf. Jag fick låna en från Audi e-Tron som vid första anblick såg ut att funka bra. Dagen efter visade det sig att det varit en illusion, batteriet var lika tomt som jag lämnat det.</p>



<figure class="wp-block-image size-large"><img decoding="async" width="1030" height="686" src="https://elbilen.se/wp-content/uploads/2020/06/DJI_0005_korr-1030x686.jpg" alt="" class="wp-image-15476" srcset="https://elbilen.se/wp-content/uploads/2020/06/DJI_0005_korr-1030x686.jpg 1030w, https://elbilen.se/wp-content/uploads/2020/06/DJI_0005_korr-300x200.jpg 300w, https://elbilen.se/wp-content/uploads/2020/06/DJI_0005_korr-768x511.jpg 768w, https://elbilen.se/wp-content/uploads/2020/06/DJI_0005_korr-1536x1022.jpg 1536w, https://elbilen.se/wp-content/uploads/2020/06/DJI_0005_korr.jpg 1600w" sizes="(max-width: 1030px) 100vw, 1030px" /><figcaption>Målgång vid Råneälven. Här fanns snö att skidra på. Och vägar att sladda på.&nbsp;</figcaption></figure>



<p></p>



<p>Och vad är den krassa elbilsrealismen i detta då? Jo att långkörningar på vintern med Nissan Leaf fungerar alldeles utmärkt om man har gott om tid. Bilen är komfortabel och pålitlig även på vinterväglag. Räckvidden och laddtiderna är godkända i elbilssammanhang men 18 timmar för en sträcka på drygt 100 mil… Nja.</p>



<p><strong>Niemisel–Örnsköldsvik. Förare: Fredrik Sandberg.</strong></p>



<p>Vi har ställt bilen i grannbyn för laddning, då uttaget vid vår stuga var upptaget av Audi e-Tron.&nbsp;</p>



<p>Vi hade laddat i 22 timmar när vi skulle hämta upp bilen. Jag trodde den skulle vara fulladdad. Leafen hade 6 procent dagen innan. När jag sätter mig i bilen i snöyran är den varm och skön men har bara laddat till … 13 procent.&nbsp;</p>



<p>Vad har hänt? Laddaren blinkar. Det visar sig att bilen har stått på hela tiden och hållit en härlig 22-gradig varm kupé med sätesvärme och allt. I 22 timmar. Så här har vi intressanta siffror. När det är minus åtta grader och bilen är påslagen får man 0,18 kWh laddning per timme. Det här var något omvänt slags laddningsrekord. Vad göra? Jag har fyra mil till en snabbladdare i Boden. Det är minus tio grader. Bilen säger att den ska gå fem mil. Jag behöver nog 20 procent i alla fall eftersom det snöar rejält och är oplogat, vilket innebär rullmotstånd och hög förbrukning. Jag väntar snällt ett par timmar och ger mig av. För säkerhets skull slår jag av värmen och jag klarar mig med 6 procent kvar till snabbladdaren i Boden. Där fyller jag upp till 83 procent på 51 minuter. Därefter Skellefteå (16 mil och 66 procents förbrukning). Målet är Örnsköldsvik. Dit är det nu är 25 mil. Jag tar mig inte på en laddning, eftersom jag slutar ladda på 80 procent. Att sitta kvar och ladda de sista 20 procenten skulle ta en timme, säger bilen. Så jag stannar hellre 20 minuter i Umeå.&nbsp;</p>



<p>Det är 4 grader när jag kommer ut på kusten. Och det är slaskigt och ett massivt regn häller över mig hela vägen till Umeå, någonting som drar mycket energi.&nbsp;</p>



<p>Hade jag fått fullt i Lassbyn hade körningen på 42 mil bara tagit 1 timme och 20 minuter längre än för en bensinbil. Det är helt okej med tanke på väderomständigheterna.&nbsp;</p>



<p>Körmässigt har Leaf lite grand överlevt sig själv. Den framhjulsdrivna bilen ger ingen direkt körglädje, det är lite stora rattutslag i en plastbalja över det hela. Men den ökade effekten på motorerna, sedan förra modellen, gör det ändå rätt okej. Men i vinterföre och mastodontregn är bilen inte den atlantångare man behöver. Räckvidd och laddning är inte uselt, men inte heller klassledande.&nbsp;</p>



<blockquote class="wp-block-quote is-layout-flow wp-block-quote-is-layout-flow"><p><strong>”Med handen på</strong> <strong>hjärtat hade jag nog klarat mig med två laddstopp.”</strong></p></blockquote>



<p><strong>Örnsköldsvik–Stockholm. Förare: Lotta Hedin.</strong></p>



<p>Leafen hade inte hunnit ladda fullt under natten och jag lämnade Ö-vik med 71 procents laddning i batteriet. Det skulle räcka i 236 kilometer, utlovade bilen. Men när jag kom ut på vägen tickade kilometerna ner snabbare än beräknat. Som gammal Leaf-förare mindes jag gissometern, och började kolla efter en laddplats på närmre håll än jag först tänkt mig.</p>



<p>Efter 134 kilometer var batteriet nere på 19 procent, och jag stannade vid Sundsvalls flygplats och laddade till 90 procent. Det borde ha kunnat ta mig till Gävle. Men efter Fredriks berättelser om kö och laddbråk vid stolpen i Gävle på vägen upp bestämde jag mig för att stanna i Söderhamn istället.&nbsp; Och sen fick det bli ett kortare stopp i Gnarp också, för jag hade inte tillräckligt med kräm i tanken att ta mig hela vägen hem.&nbsp;</p>



<p>Med handen på hjärtat hade jag nog klarat mig med två laddstopp, om jag varit lättare på foten och planerat stoppen bättre. Men jag var trött och ville hem. Det blåste också kraftig motvind och det var svårt att beräkna hur mycket energi som skulle gå åt. Energiförbrukningen under sträckan låg på i genomsnitt 18 kWh/100 km.</p>



<p>Körmässigt känns Leafen ganska slätstruken, den sticker inte ut åt något håll och lämnar inga avtryck.&nbsp;</p>



<p style="color:#20bdc4" class="has-text-color has-text-align-center">AUDI E-TRON 50 QUATTRO</p>



<p><strong>Stockholm–Niemisel. Förare: Fredrik Sandberg.</strong></p>



<p>Audi e-Tron 50 ska klara 332 km på en laddning, i blandad körning. Kia e-Niro ska klara 455 km och Nissan Leaf e+ 385 km.&nbsp;</p>



<p>Audi e-Tron har ju funnits ett tag på marknaden, men den bil vi nu testar har ett mindre batteri. I stället för 95 kWh är den bestyckad med ett batteri på 71 kWh. Tillgänglig mängd är dock 64,7 kWh.&nbsp;</p>



<p>Det innebär att Audi faktiskt har lika mycket batterikapacitet som en Kia e-Niro, där batteriets tillgängliga energi är 64 kWh. Nissan Leaf anger 62 kWh batterimängd, men där har man uppskattningsvis 56 kWh tillgängligt (enligt ev-database.org).&nbsp;</p>



<p>Jag får kliva in i komfortzonen som är Audi e-Tron. De 100 milen norrut är genomgående verkligen smärtfria i den höga bilen som är mjukt fjädrad, i härliga stolar och med med skön värme och en ljudisolering av högsta klass.&nbsp;</p>



<p>En av de mest behagliga sakerna med e-Tron på motorvägen är farthållaren som sänker och höjer hastigheten extremt precist vid hastighetsskyltarna. Blir det 70-väg från 90 så bromsar bilen in innan skylten och exakt när man passerar den håller man rätt hastighet. Men filhållarassistenten påminner mig hela tiden att jag ska hålla händerna på ratten, men den är väldigt okänslig – även när jag håller i ratten måste den vridas till ganska ordentligt hela tiden så att den känner av att jag är vaken, vilket är aningen irriterande.&nbsp;</p>



<p>Första stoppet blir i Gävle, redan efter 17 mils körning. Det är kö vid två laddare. Och bråk vid en av dem. Fyra bilar vill komma åt en sladd. Jag hittar en tredje. Det blir en dryg timmes rast med en kopp kaffe. Jag laddar från 24 till 98 procent på 63 minuter. Nästa stopp blir i Sundsvall, dit det är 21 mil. Jag har 13 procent kvar när jag anländer. En timme och tio minuter till vid laddaren och lunch. Sedan vidare. Nu blir det kallare och stoppen blir fler. Jag inser att jag inte tar mig till Umeå, 25 mil bort, och fyller på redan efter 15 mil. Det blir 40 minuter i Örnsköldsvik, 40 minuter i Umeå och sedan 36 minuter i Skellefteå. Det är cirka 13 mil mellan hållplatserna. Jag har 79 procent i Skellefteå och tar mig till Luleå och har 13 procent kvar vid ankomst, efter att ha fyllt upp 8 procent i Piteå. I Luleå laddar jag på en HPC-laddare. Jag hade klarat mig sista fem milen, men knappt. Nu får jag se hur bra Audi laddar i minus 17 grader. Och det är inte tokigt alls (se laddkurva).&nbsp;</p>



<p><strong>Niemisel–Örnsköldsvik. Förare: Lotta Hedin.</strong></p>



<p>I det vedervärdiga väder som rådde på hemresedagen kändes det som att jag dragit vinstlotten när jag fick köra Audi E- tron. Snödrev och fyrhjulsdrift är en bra kombination, och e-Tron glänste med sin grymma väghållning.</p>



<p>Trots kastvindar och mängder med snö på vägarna, som längre söderut blev störtskurar och stora vattensamlingar, kände jag mig trygg. Bilens antisladdsystem fick jobba. De blixtsnabba justeringarna mellan bakre och främre motor för att parera bristande fäste och oväntat motstånd i snödrivorna kändes i bilen, utan att bli obekvämt.&nbsp;</p>



<p>Räckvidden i detta väder glänste däremot inte lika mycket. Energiförbrukningen snittade på drygt 28 kWh/ 100 km. Enligt bilens egna beräkningar kom jag bara lite drygt 20 mil på ett fulladdat batteri. Den höga laddkapaciteten fick jag heller inte åtnjuta. Trots att laddaren i Luleå kan leverera 175 kW, tog Audi E- tron som mest emot 67 kW där.</p>



<figure class="wp-block-image size-large"><img decoding="async" width="1030" height="643" src="https://elbilen.se/wp-content/uploads/2020/06/DJI_0035-1030x643.jpg" alt="" class="wp-image-15484" srcset="https://elbilen.se/wp-content/uploads/2020/06/DJI_0035-1030x643.jpg 1030w, https://elbilen.se/wp-content/uploads/2020/06/DJI_0035-300x187.jpg 300w, https://elbilen.se/wp-content/uploads/2020/06/DJI_0035-768x480.jpg 768w, https://elbilen.se/wp-content/uploads/2020/06/DJI_0035-1536x959.jpg 1536w, https://elbilen.se/wp-content/uploads/2020/06/DJI_0035.jpg 1600w" sizes="(max-width: 1030px) 100vw, 1030px" /></figure>



<p>Det fick bli tre laddstopp på den 458 kilometer långa sträckan. Jag lämnade Lassbyn, grannby till Niemisel där jag lämnade av Fredrik till Leafen som stått på laddning över natten kl 11.01 och kom fram till hotellet i Örnsköldsvik klockan 19.45, då med 100 kilometers räckvidd kvar. Resan tog med andra ord en hel del tid, men ändå skulle jag inte ha velat sitta i någon annan bil än just e-Tron den dagen.</p>



<p><strong>Örnsköldsvik–Uppsala. Förare: Ida Karlsson.</strong></p>



<p>Även fast vi avverkat 43 mil är det ändå 53 mil kvar. Nu har jag dessutom en deadline eftersom mitt tåg går 16.30. Är det rimligt att beräkna restid på 7,5 timme för den sträckan? Ja, om man absolut ska köra elbil och får för sig att skaffa en Audi e-Tron med lilla batteriet. Det här är en knasig variant av den bil som med det stora batteriet klarade av att både avverka tio länder på 24 timmar samt ett 16-tonssläp på tractor pulling. Varför erbjuder man en futtig räckvidd på cirka 25 mil? För en ”rabatt” på cirka 90 000 kr?&nbsp;</p>



<p>Kvaliteten, körkänslan och komforten är oslagbar, och naturligtvis är fyrhjulsdriften ett plus. Den här dagen bjuder på storm, och det rapporteras om singelolyckor och nedfallna träd på vägarna. Men e-Tron rullar stadigt på, något annat är inte att vänta. Tyvärr räcker det inte hela vägen. Efter dagens andra laddstopp, som sker i Gävle, inser jag att jag inte kommer att hinna till Stockholm. Det gick alltså inte att ta sig 53 mil på under 7,5 timmar! Jag ringer Fredrik för att fråga om jag kan lämna bilen i Uppsala, då hinner jag med tåget därifrån klockan 17. Fredrik möter upp mig vid centralstationen 16.15, då jag lämnar över nycklarna och det här elbilsäventyret för att ta det säkraste och mest hållbara transportsättet norrut: tåget.</p>



<blockquote class="wp-block-quote is-layout-flow wp-block-quote-is-layout-flow"><p>”Det fick bli tre laddstopp på den 458 kilometer långa sträckan.”</p></blockquote>



<p>P.S. Läs mer <a href="https://elbilen.se/artiklar/statistik-kungen-av-langkorning-i-norr/" class="yoast-seo-link">statistik om resan här!</a></p>



<h2 class="wp-block-heading">Snabbfakta</h2>



<div class="wp-block-columns is-layout-flex wp-container-core-columns-is-layout-9d6595d7 wp-block-columns-is-layout-flex">
<div class="wp-block-column is-layout-flow wp-block-column-is-layout-flow">
<div class="wp-block-cover has-very-dark-gray-background-color has-background-dim"><div class="wp-block-cover__inner-container is-layout-flow wp-block-cover-is-layout-flow">
<h2 class="wp-block-heading">Kia e-Niro EV</h2>



<p>Pris :481 900 kr</p>



<p>Batteristorlek: 64 kWh (netto)</p>



<p>Räckvidd: 455 km (WLTP)</p>



<p>Laddkapacitet CCS: 100 kW</p>



<p>Drivning: Framhjulsdrift</p>



<p>Antal sittplatser: 5</p>



<p>Vikt: 1 843 kg</p>
</div></div>
</div>



<div class="wp-block-column is-layout-flow wp-block-column-is-layout-flow">
<p></p>



<h2 class="wp-block-heading">Audi e-Tron 50 quattro&nbsp;</h2>



<p>Pris: 695 000 kr</p>



<p>Batteristorlek: 71 kWh (brutto)</p>



<p>Räckvidd: 299 km (WLTP)</p>



<p>Laddkapacitet: 120 kW</p>



<p>Drivning: Fyrhjulsdrift</p>



<p>Antal sittplatser: 5</p>



<p>Vikt: 2 490 kg</p>
</div>



<div class="wp-block-column is-layout-flow wp-block-column-is-layout-flow">
<div class="wp-block-cover has-very-dark-gray-background-color has-background-dim"><div class="wp-block-cover__inner-container is-layout-flow wp-block-cover-is-layout-flow">
<h2 class="wp-block-heading">Nissan Leaf E+ 62 kWh&nbsp;</h2>



<p>Pris: 461 500 kr</p>



<p>Batteristorlek: 62 kWh</p>



<p>Räckvidd: 385 km (WLTP)</p>



<p>Laddkapacitet: 100 kW</p>



<p>Drivning: Framhjulsdrift</p>



<p>Antal sittplatser: 5</p>



<p>Vikt: 1 545 kg</p>
</div></div>



<p></p>
</div>
</div>



<h2 class="wp-block-heading">Data från resan:</h2>



<h2 class="has-text-color wp-block-heading" style="color:#20bdc4">70</h2>



<p>km/h blir det plötsligt på 110-väg med farthållaren i Audin. Det sker när man passerar under en bro och gps:en plötsligt tror att det är 70-väg för att vägen ovanpå har den hastigheten. Utrymme för förbättringar finns.&nbsp;</p>



<h2 class="wp-block-heading">3,36</h2>



<p>kWh/mil drar Audi e-Tron 50 när det är –17,5 grader i 110 km/h. Det ger en räckvidd på 19 mil från fullt till tomt. Kör man med marginaler innebär det cirka 15 mil.&nbsp;</p>



<h2 class="has-text-color wp-block-heading" style="color:#20bdc4">60</h2>



<p>minuter tog det att ladda 60 procent i Nissan Leaf vid första laddstoppet. Vid näst sista längre laddstoppet av sex, tog det 72 minuter att ladda 66 procent. Rapidgate, där upprepade laddningar gör laddningen långsam, verkar inte vara fallet för Leaf e+. Däremot gick det trögt på den laddare som skulle ge 100 kW. Den kom aldrig över 47 kW och blev snabbt långsam. Men då var det –14 grader kallt.&nbsp;</p>



<h2 class="wp-block-heading">8,32</h2>



<p>kWh krävde Kia e-Niro för att köra 5,5 mil i –17 grader. Det är en förbrukning på 1,66 kWh per mil. Snitthastigheten var inte så hög utan låg på 68 km/h. Imponerande i så kallt klimat.&nbsp;</p>



<h2 class="has-text-color wp-block-heading" style="color:#20bdc4">28&nbsp;</h2>



<p>procent av batteriet gick åt för att köra fem mil för Nissan Leaf, sista sträckan i –20 grader. Det är drygt 3 kWh per mil. Bilen förbrukar då cirka dubbelt så mycket som vid +20 grader.&nbsp;</p>



<h2 class="wp-block-heading">7</h2>



<p>procent laddade Nissan Leaf på 22 timmar när bilen var på- slagen med kupévärmen på 22 grader och sätesvärme påslagen i minus åtta grader.&nbsp;</p>



<h2 class="has-text-color wp-block-heading" style="color:#20bdc4">27,3&nbsp;</h2>



<p>kWh var snittförbrukningen i Audie e-Tron quattro 50 efter drygt 200 mil tur och retur till Norrbotten från Stockholm.&nbsp;</p>



<h2 class="wp-block-heading">19,6</h2>



<p>kWh var snittförbrukningen i Kia e-Niro efter dryga 200 mils körning från Stockholm till Norrbotten.&nbsp;</p>



<h2 class="has-text-color wp-block-heading" style="color:#20bdc4">21,1</h2>



<p>kWh var snittförbrukningen i Nissan Leaf efter dryga 200 mils körning från Stockholm till Norrbotten.&nbsp;</p>



<h2 class="wp-block-heading">6</h2>



<p>hamburgare, två sushi, en pyttipanna, en söndagsbuffé, två påsar älgkorv, en påse linschips och fyra godispåsar slukades sammanlagt under resan. Det behövs fler ställen med nyttig mat vid snabbladdarna!&nbsp;</p>



<h2 class="has-text-color wp-block-heading" style="color:#20bdc4">3</h2>



<p>laddstopp kräver den mest effektiva bilen, Kia e-Niro för att ta sig 100 mil i kyla. Nissan Leaf gjorde det på det dubbla, så även e-Tron. För Nissan Leaf var problemet långa laddtider över 80 procent, för e-Tron hög för- brukning.</p>



<h2 class="has-text-align-center wp-block-heading">Betyg för långkörning i vinterlandskap</h2>



<p>Här ger vi de tre bilarna betyg kring hur de fungerade på långresa mot kallare klimat. Vi har test bilarna i tidigare nummer, här fokuserar vi just på långkörning mot snön.</p>



<p style="color:#20bdc4" class="has-text-color">Nissan Leaf e+</p>



<figure class="wp-block-image size-large"><img decoding="async" width="512" height="284" src="https://elbilen.se/wp-content/uploads/2020/06/unnamed-66.jpg" alt="" class="wp-image-15493" srcset="https://elbilen.se/wp-content/uploads/2020/06/unnamed-66.jpg 512w, https://elbilen.se/wp-content/uploads/2020/06/unnamed-66-300x166.jpg 300w" sizes="(max-width: 512px) 100vw, 512px" /></figure>



<p>Räckvidd: 3</p>



<p>Nissan Leaf e+ har en i grunden bra räckvidd. Vi tar oss säkra 25 mil i kyligare klimat och har 22 procent kvar i batteriet. Vi höll då en beskedlig hastighet. Men det visar att 30 mil även på vintern inte är omöjligt. På sommaren lär det bli än bättre. Leafs nackdel på långtur handlar mer om nästa punkt: laddningen.&nbsp;</p>



<p>Laddkapacitet i kyla: 3</p>



<p>Att köra långt med Leaf innebär att man laddar till 80 procent. Det tar dryga timmen från under 10 procent. Att ladda vidare från 80 till 100 procent tar nästan lika lång tid. Det innebär att långkörningen får ske på cirka 70 procent av batteriet (med 10 procents marginal). Det ger körsträckor i realiteten på 20 mil: 70 % av 56 kWh (verklig kapacitet) = 39,2 kWh. Leaf e+ drar dryga 2 kWh per mil. 39,2/2,1 = 18,6 mil. Men Leaf e+ klarade dock upprepade snabbladdningar utan att tappa alltför mycket i kapacitet.</p>



<p>Komfort: 3</p>



<p>Förarsätet känns lite trångt för benen jämfört med Kian och framför allt Audin, även om den senare är i en helt annan priskategori. Men fjädringen är okej och komforten bak rimlig även för längre resor. Bra värme i kupén även i tuffare minusgrader. Ett stort plus är den automatiska avbländaren som är precis och har snabb respons. Här är Nissan faktiskt långt bättre än exempelvis Teslas Model 3. Vi gillar även one pedal-driving. Men lane assisten funkar dåligt i regn.&nbsp;&nbsp;</p>



<p>Köregenskaper: 3</p>



<p>Nya Leaf har fått större motor vilket gör den bättre än tidigare modell, framför allt på motorvägen. Framhjulsdriften är aningen slirig och det känns lite som Bambi på hal is med friktionsdäck i snön.&nbsp; </p>



<p>Summa: 12 av 20</p>



<p style="color:#20bdc4" class="has-text-color">Kia e-Niro</p>



<figure class="wp-block-image size-large"><img decoding="async" width="980" height="602" src="https://elbilen.se/wp-content/uploads/2020/06/KIA.jpg" alt="" class="wp-image-15494" srcset="https://elbilen.se/wp-content/uploads/2020/06/KIA.jpg 980w, https://elbilen.se/wp-content/uploads/2020/06/KIA-300x184.jpg 300w, https://elbilen.se/wp-content/uploads/2020/06/KIA-768x472.jpg 768w" sizes="(max-width: 980px) 100vw, 980px" /></figure>



<p>Räckvidd: 5</p>



<p>100 mil kräver tre laddstopp även när halva den resan är i Norrland och övre delen i rätt griniga minusgrader, ner till –20 vid målet. Kia har byggt en riktigt bra vinterbil. Den får högsta betyg genom att den även är strömsnål i lägre temperaturer.&nbsp;</p>



<p>Laddkapacitet i kyla: 3</p>



<p>Här blir det sämre. 67 kW kommer laddningen upp till på HPC-laddaren i Luleå, där det var –10 grader. Och det för en kort stund, för det mesta låg laddningen på under 50 kW. Det blir också likt Leafen rätt segt över 80 procent, men e-Niro har större batteri och är snålare vilket ger möjlighet till längre körningar per laddning.&nbsp;</p>



<p>Komfort: 3</p>



<p>Man sitter rätt högt, tar sig in nyckellöst och de eldrivna stolarna är lätta att justera in för en skön långsittning.&nbsp;</p>



<p>Det är rätt mycket knappar som man inte behöver, vi kopplar in Apple Car play och använder Google Maps. En uppgraderad bil med större skärm är på väg ut till handlarna.</p>



<p>Köregenskaper: 3</p>



<p>E-Niro ger en ganska anonym körupplevelse, med en rätt slirig framhjulsdrift. Vi fastnar på en isfläck med de odubbade däcken, men lyckades ta oss loss. Dubbdäck är ett måste för den som rör sig i snöiga områden. Den presterar väl på motorvägen, men ger ingen direkt körglädje. &nbsp;</p>



<p>Summa: 14 av 20</p>



<p style="color:#20bdc4" class="has-text-color">Audi e-Tron 50 quattro</p>



<p>Räckvidd: 3</p>



<p>Den här trean sitter löst. Låt oss kalla det en svag trea. Med fulladdat batteri tar vi oss knappt 20 mil i minus 17 grader med fulladdat batteri. I mildare temperatur blir en 21,5-milatripp ganska precis vad man klarar om man vill ha lite marginal, vi har 13 procent kvar vid målet. Bor man i södra Sverige och inte kör norrut är det här bättre, dessutom kommer allt fler HPC-laddare upp. Men som vinterbil i Norrbotten är den tveksam.&nbsp;</p>



<p>Laddkapacitet i kyla: 4</p>



<p>I minus tio grader kommer Audi ändå upp i 90 kW. Det är bra. Men den når inte upp till de utlovade 120 kW. Vi försöker även när det är nollgradigt och då når den 94 kW. Däremot ligger den och laddar på över 40 kW även när batteriet har 89 procent. Till 100 går med andra ord ganska fort, och det behövs med tanke på räckvidden.&nbsp;</p>



<p>Komfort: 5</p>



<p>Det är varmt och ombonat med riktigt härliga säten. Kvalitetskänslan är genomgående och bilen är byggd för riktigt långa turer, med en underbar fjädring. Parat med den höga sittpositionen blir det högsta betyg. Är man bara beredd på många laddstopp är det här en riktig långkörarbil.&nbsp;</p>



<p>Köregenskaper: 5</p>



<p>Det är här som Audi e-Tron briljerar. Med ett oerhört sofistikerat fyrhjulsdriftssystem är det nära nog som att köra på asfalt i snön. Vi tvärnitar på ett ställe och bilen gör som vi säger. På snöigt underlag. Odubbat. Trygg och säker i oplogad miljö. Den raska accelerationen på motorvägen ger trygga omkörningar.&nbsp;</p>



<p>Summa: 17 av 20</p>



<figure class="wp-block-gallery columns-3 is-cropped wp-block-gallery-2 is-layout-flex wp-block-gallery-is-layout-flex"><ul class="blocks-gallery-grid"><li class="blocks-gallery-item"><figure><img decoding="async" width="512" height="337" src="https://elbilen.se/wp-content/uploads/2020/06/unnamed-71.jpg" alt="" data-id="15498" data-link="https://elbilen.se/?attachment_id=15498" class="wp-image-15498" srcset="https://elbilen.se/wp-content/uploads/2020/06/unnamed-71.jpg 512w, https://elbilen.se/wp-content/uploads/2020/06/unnamed-71-300x197.jpg 300w" sizes="(max-width: 512px) 100vw, 512px" /></figure></li><li class="blocks-gallery-item"><figure><img decoding="async" width="512" height="341" src="https://elbilen.se/wp-content/uploads/2020/06/unnamed-70.jpg" alt="" data-id="15499" data-link="https://elbilen.se/?attachment_id=15499" class="wp-image-15499" srcset="https://elbilen.se/wp-content/uploads/2020/06/unnamed-70.jpg 512w, https://elbilen.se/wp-content/uploads/2020/06/unnamed-70-300x200.jpg 300w" sizes="(max-width: 512px) 100vw, 512px" /></figure></li><li class="blocks-gallery-item"><figure><img decoding="async" width="1030" height="687" src="https://elbilen.se/wp-content/uploads/2020/06/DSC06850-1030x687.jpg" alt="" data-id="15500" data-full-url="https://elbilen.se/wp-content/uploads/2020/06/DSC06850.jpg" data-link="https://elbilen.se/?attachment_id=15500" class="wp-image-15500" srcset="https://elbilen.se/wp-content/uploads/2020/06/DSC06850-1030x687.jpg 1030w, https://elbilen.se/wp-content/uploads/2020/06/DSC06850-300x200.jpg 300w, https://elbilen.se/wp-content/uploads/2020/06/DSC06850-768x512.jpg 768w, https://elbilen.se/wp-content/uploads/2020/06/DSC06850-1536x1024.jpg 1536w, https://elbilen.se/wp-content/uploads/2020/06/DSC06850.jpg 1600w" sizes="(max-width: 1030px) 100vw, 1030px" /></figure></li></ul></figure>



<h2 class="has-text-align-center wp-block-heading">Och vinnaren är:</h2>



<p style="color:#20bdc4" class="has-text-color">Audi e-Tron &nbsp;</p>



<p>Med god marginal. Men det kanske inte är så förvånande, vi jämför ju lite äpplen och päron här. En bil för 700 000 kronor ska vara bättre än en som kostar under 500 000. Ändå är det den billigare e-Niron som är en klass bättre när det kommer till förbrukning och därmed räckvidd. E-Tron 50 och e-Niro har lika stort batteri (netto), men helt olika räckvidd. Nissan Leaf e+ är en duglig bil, men som börjar kännas lite daterad. Det syns på försäljningen. Nissan hade en gång ledningen i elbilsvärlden, nu krävs det någonting vassare. Konkurrensen hårdnar. E-Niro känns däremot som en bil som kommer att hålla i alla fall ett par år till.&nbsp;</p>



<p>Vi måste också lägga in en notering. Vi tänkte ta inlandet på hemvägen, men de få laddstationerna gjorde att den beräknade körtiden skulle ha blivit för lång. Så det blev kuststräckan tillbaka. Nu måste åtgärder vidtas för att fler HPC-laddare byggs även i glesbygden. Modell­utbudet kommer att öka markant de kommande åren.</p>



<div class="wp-block-columns is-layout-flex wp-container-core-columns-is-layout-9d6595d7 wp-block-columns-is-layout-flex">
<div class="wp-block-column is-layout-flow wp-block-column-is-layout-flow">
<figure class="wp-block-image size-large"><img decoding="async" width="512" height="281" src="https://elbilen.se/wp-content/uploads/2020/06/unnamed-69.jpg" alt="" class="wp-image-15495" srcset="https://elbilen.se/wp-content/uploads/2020/06/unnamed-69.jpg 512w, https://elbilen.se/wp-content/uploads/2020/06/unnamed-69-300x165.jpg 300w" sizes="(max-width: 512px) 100vw, 512px" /><figcaption>Laddning på HPC-laddare tog från 22 procent till 100 procent 51 minuter<br>och 41 sekunder. Laddaren levererade 53,537 kWh.<br></figcaption></figure>
</div>



<div class="wp-block-column is-layout-flow wp-block-column-is-layout-flow">
<figure class="wp-block-image size-large"><img decoding="async" width="512" height="325" src="https://elbilen.se/wp-content/uploads/2020/06/unnamed-68.jpg" alt="" class="wp-image-15496" srcset="https://elbilen.se/wp-content/uploads/2020/06/unnamed-68.jpg 512w, https://elbilen.se/wp-content/uploads/2020/06/unnamed-68-300x190.jpg 300w" sizes="(max-width: 512px) 100vw, 512px" /><figcaption>E-Niron kom som mest upp till 67 kW på HPC-laddaren i Luleå. Sedan segade<br>den sig ner. Vi har inte lyckats få den upp till 100 kW ens på sommaren då den vek av vid cirka 70 kW.<br></figcaption></figure>



<p></p>
</div>



<div class="wp-block-column is-layout-flow wp-block-column-is-layout-flow">
<figure class="wp-block-image size-large"><img decoding="async" width="512" height="275" src="https://elbilen.se/wp-content/uploads/2020/06/unnamed-67.jpg" alt="" class="wp-image-15497" srcset="https://elbilen.se/wp-content/uploads/2020/06/unnamed-67.jpg 512w, https://elbilen.se/wp-content/uploads/2020/06/unnamed-67-300x161.jpg 300w" sizes="(max-width: 512px) 100vw, 512px" /><figcaption>Nissan Leaf e+ som vi körde ska kunna ta 100 kW. Det har vi inte lyckats med tidigare, och det blev inte av denna gång heller. Laddaren i Luleå ska kunna ge 175 kW. Men vi kom inte över 45 kW. Intressant nog så laddade Leaf e+ tämligen lika under hela resan.</figcaption></figure>



<p></p>
</div>
</div>



<h2 class="wp-block-heading">Våra val av vinterbil</h2>



<p><strong>Idas val</strong></p>



<p>Den här resan väckte en otålighet kring att det fortfarande tar så lång tid att bygga fler och snabbare laddare. Alla tre bilar är utmärkta pendlarbilar. Räckvidden är så pass bra att man knappast behöver bekymra sig för att komma fram även en snöig och kall dag. På Kia E-Niro och Audi e-Tron kan man dessutom appstyra laddningen och optimera temperaturen på batteriet. På långresa – där blir Kia e-Niro den stora vinnaren. Det är den jag väljer. Men jag vill ha den med fyrhjulsdrift, då blir det en perfekt Norrlandsbil.</p>



<p><strong>Lottas val</strong></p>



<p>Helst skulle jag vilja ha en kombination av Kia e-Niros räckvidd och den grymma väghållningen och sköna köregenskaperna hos Audi e-Tron 50. Av dessa tre testade modeller skulle jag välja Kia e–Niro. Den fantastiska energisnålheten väger tungt, och det är dessutom en mycket trevlig bil att köra med många bra funktioner och bra last­utrymmen. Årsmodell 20 (den vi provkörde var 19) har dessutom trefasladdning.</p>



<p>Det är klart att det skulle vara trevligt med en Audi e-Tron, den är allra bäst av de tre på vägen. Men jag skulle inte lägga 799 000 kronor (även om den i skrivande stund finns till kampanjpris på strax under 700 000 kr) på en e-Tron 50 quattro med 71 kW batteri, som vi testade nu. Om jag skulle köpa en e-Tron skulle jag se till att hosta upp 92 000 till och köpa en e-Tron 55 quattro, med det större batteriet. Att göra en så kompetent och välbyggd bil och ge den så kort räckvidd som versionen med det mindre batteripacket i praktiken har – det känns lite som slöseri.</p>



<p><strong>Fredriks val</strong></p>



<p>Det smärtar, men jag måste nog ta en Kia e-Niro. Audi e-Tron 50 quattro är ju en så mycket bättre bil när det kommer till … tja, allt. Förutom räckvidden. Det blir ganska många stopp för att ta sig fram, med lilla batteripacket. Till och med e-Tron 55 med 95 kWh får nog svårt att slå Kia e-Niro, som med endast 64 kWh verkligen kramar det mesta ur batteriet. Sista sträckan hem, från Örnsköldsvik till Stockholm på 53 mil i nollgradig temperatur, gjordes med ett laddstopp i Söderhamn.&nbsp;</p>



<p>På sommaren lär alla bilarna prestera bättre, men då kommer en dryga 50-milskörning gå med ett tämligen kort laddstopp med Kian, vilket vi testade i somras då vi fick en närmast 50-milaräckvidd med bilen.&nbsp;</p>



<p>Två bilar vore det ultimata i det här fallet. En Kia att köra upp till snön med och en Audi på plats att tröska runt i snön med. Den tunga bilen med fyrhjulsdriften är fantastisk.</p>



<figure class="wp-block-image size-large"><img decoding="async" width="687" height="1030" src="https://elbilen.se/wp-content/uploads/2020/06/93A2667-687x1030.jpg" alt="" class="wp-image-15504" srcset="https://elbilen.se/wp-content/uploads/2020/06/93A2667-687x1030.jpg 687w, https://elbilen.se/wp-content/uploads/2020/06/93A2667-200x300.jpg 200w, https://elbilen.se/wp-content/uploads/2020/06/93A2667-768x1152.jpg 768w, https://elbilen.se/wp-content/uploads/2020/06/93A2667-1024x1536.jpg 1024w, https://elbilen.se/wp-content/uploads/2020/06/93A2667.jpg 1067w" sizes="(max-width: 687px) 100vw, 687px" /></figure>
