
<p class="has-drop-cap wp-block-paragraph">Efter tre segrar och ett andrapris i försöken står Fredrik Wallin bakom en fjärdedel av finalfältet i stonas långa final. Gävletränaren har flyttat fram sina positioner på senare år har har en hel del stora unghästsegrar på meritlistan, men i E3-sammanhang väntar han på en stor framgång.</p>



<p class="wp-block-paragraph"><strong>Tohotforyou</strong> (e. Scarlet Knight) var tvåa bakom Princess Face i korta upplagan för ston för tio år sedan, medan det blev en tredjeplats för <strong>Global Destination</strong> (e. S.J.’s Caviar) i långa finalen för hingstar och valacker 2022.</p>



<p class="wp-block-paragraph"><strong>Bonsse Garde</strong> (e. Makethemark), <strong>Pure Athena</strong> (e. Bar Hopping), <strong>Global Got It All</strong> (e. Walner) och <strong>Global Genesis</strong> (e. Nuncio) är kvartetten i lördagens stofinal.<br>– Det var otroligt kul att få de framskjutna placeringar man fick. Pure Athena har så mycket fart i sina ben och fick en körare mitt i loppet. Hon kändes obrukad när hon kom in i stallet efteråt. Hon har så mycket mental styrka och ligger långt före de andra på just den biten, sade Fredrik Wallin till V65 Direkt.</p>



<p class="wp-block-paragraph"><em>Kan någon stallkamrat utmana henne om segern?</em><br>– Bonsse Garde blir spännande när vi rycker skorna på henne för första gången. Hon är en naturtravare. Global Got It All gjorde ett riktigt bra lopp senast. Jag har väntat på att hon ska visa att det är en bra häst och jag har kört henne tungt balanserad, sade Wallin.</p>



<h2 class="wp-block-heading">Startlista E3 ston</h2>



<p class="wp-block-paragraph">2.140 meter autostart, Eskilstuna lördag<br><em>Namn (far) – Kusk (tränare)</em></p>



<ol class="wp-block-list">
<li>Bonsse Garde (e. Makethemark) – Magnus A Djuse (Fredrik Wallin)</li>



<li>Pure Stella (e. Readly Express) – Jorma Kontio (Katja Melkko)</li>



<li>Pure Athena (e. Bar Hopping) – Carl Johan Jepson (Fredrik Wallin)</li>



<li>Global Got It All (e. Walner) – Björn Goop (Fredrik Wallin)</li>



<li>Kobra Brick (e. Readly Express) – Mika Forss (Petri Salmela)</li>



<li>Global Genesis (e. Nuncio) – Gustav Johansson (Fredrik Wallin)</li>



<li>Precious Steel (e. Muscle Hill) – Johan Untersteiner</li>



<li>Whammy (e. Mosaique Face) – Mats E Djuse (Mattias Djuse)</li>



<li>Housekeeper (e. Trixton) – Claes Sjöström (Roger Walmann)</li>



<li>Gourmet d’Arc (e. Six Pack) – Robin Bakker (Paul Hagoort)</li>



<li>Global Good News (e. S.J.’s Caviar) – Andreas Lövdal</li>



<li>Västerbo Carretera (e. Maharajah) – Rikard N Skoglund (Sybille Tinter)</li>
</ol>



<p class="has-text-align-center wp-block-paragraph">***</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/06/kobrabrickmfadam-617x333.jpg" alt="" class="wp-image-732243"/><figcaption class="wp-element-caption">Petri Salmela-tränad Kobra Brick är fortfarande obesegrad felfri efter sex vinster på åtta starter. Foto Adam Ström/Stalltz.se</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">Petri Salmela var mannen bakom 2009 års vinnare <strong>My Love di Quattro</strong> (e. Love You). 16 år senare kan han lägga beslag på en ny segerkrans med god hjälp av Mika Forss som är med och sköter mycket av det dagliga med det Stockholmsbaserade stoet <strong>Kobra Brick</strong> (e. Readly Express).</p>



<p class="wp-block-paragraph">Mika Forss lyfter fram Kobra Brick som en av de bästa hästar han kört – någonsin.<br>– Kobra håller samma klass som Lara Boko och hon sprang in tio miljoner. Kobra är en av de bästa hästar jag kört, sade Mika Forss till V65 Direkt.</p>



<p class="wp-block-paragraph">Kobra Brick svarade för en toppinsats från dödens i försöket på näst snabbaste vinnartiden, 1.12,5a/2.140 meter, och då satt Forss mest och markerade konkurrenterna över upploppet. Dock har Kobra Brick gjort bort sig med galopp två gånger.<br>– Spåret är perfekt, att hon galopperat beror på att hon är så pigg att man måste hålla i henne för hon kan slå ihop. När det gått några steg är det ingen stor galopprisk. Nu tävlar hon barfota, det blir lättare att springa och benen hinner med bättre än när hon går med skor. Hennes steg är att det passar perfekt barfota, sade Mika Forss.</p>



<p class="wp-block-paragraph"><em>Segerchansen?</em><br>– Jag hoppas att vi slipper otur, för går hon felfritt tror jag att hon vinner. Dödens eller annan resa spelar ingen roll. Jag är inte orolig för dödens.</p>



<p class="has-text-align-center wp-block-paragraph">***</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/06/purestellajk-617x333.jpg" alt="" class="wp-image-736820"/><figcaption class="wp-element-caption">Pure Stella och Jorma Kontio. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">Blått och vitt på blågul mark handlar även om för den femte försöksvinnaren <strong>Pure Stella</strong> (e. Readly Express). Katja Melkko tränar stoet och Jorma Kontio sitter som vanligt i vagnen bakom Pure Stella, som gjorde debut i början av mars med en andraplats på 1.205 med galopp.</p>



<p class="wp-block-paragraph">Utvecklingen har gått snabbt. I maj vann hon en avdelning i Margaretas Tidiga Unghästserie och tog sjätteplatsen i Breeders Course-finalen för ston.</p>



<p class="wp-block-paragraph">Pure Stella är en av blott tre finalister som inte var ute och tävlade som tvååringar. De övriga som debuterat i år är <strong>Global Genesis</strong> (e. Nuncio) och <strong>Global Good News</strong> (e. S.J.’s Caviar).</p>



<p class="has-text-align-center wp-block-paragraph">***</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2018/01/nelnhansportr2-617x288.jpg" alt="Sulkysport, Travsport, Hans Nelén" class="wp-image-17811"/><figcaption class="wp-element-caption">Hans Nelén. Foto Mia Törnberg/Sulkysport

</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">En gång har Global Farm stått bakom vinnare i en E3-final som uppfödare: 2020 segrade Daniel Wäjersten med <strong>Global Badman</strong> (e. Yield Boko) i långa finalen för hingstar och valacker på Bergsåker.</p>



<p class="wp-block-paragraph">I årets stofinal har Hans Nelén – mannen bakom Global Farm – hela tre uppfödningar inkvalade. Global Got It Al (e. Walner) vann försöket, medan <strong>Global Genesis</strong> (e. Nuncio) och <strong>Global Good News</strong> (e. S.J.’s Caviar) slutade tvåa i sina uttagningslopp.<br>Förra året var Global Farm trea i svenska uppfödarligan bakom Menhammar Stuteri och Am Bloodstock.</p>



<p class="wp-block-paragraph">En annan uppfödare med tre chanser i E3-finalerna är Marko Kreivi. Kullens drottning <strong>Pure Athena</strong> (e. Bar Hopping) och <strong>Pure Stella</strong> (e. Readly Express) är hoppen i stoklassen, medan <strong>Pure Count</strong> (e. Googoo Gaagaa) kvalade in i hingstarnas och valackernas final.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/fokus/marko-har-tre-chanser-att-vinna-e3/" target="_blank" rel="noreferrer noopener">––> Läs mer om Marko Kreivi och hans uppfödning och hästägande här!</a></p>



<p class="wp-block-paragraph"><strong>Ägare och uppfödare till E3-finalisterna:</strong><br><em>Namn – Ägare – Uppfödare</em></p>



<ul class="wp-block-list">
<li>Bonsse Garde – Terästallit Oy &#038; Garde Hästar AB – Garde Hästar AB, Sala</li>



<li>Pure Stella – Göteborg Smart Repair Center AB – Marko Kreivi, Rönnäng</li>



<li>Pure Athena – Göteborg Smart Repair Center AB – Marko Kreivi, Rönnäng</li>



<li>Global Got It All – Stall MajKen HB, med flera – Global Farm AB, Nacka Strand</li>



<li>Kobra Brick – Bilhallen i Piteå AB, med flera – Anders Bredberg, Tystberga</li>



<li>Global Genesis – Stall Fredrik Wallin AB, med flera – Global Farm AB, Nacka Strand</li>



<li>Precious Steel – Merwestaal Racing Stables B.V. – Michel de Bruin, Nederländerna</li>



<li>Whammy – Tie HB, Sundsvall – Tie HB, Sundsvall</li>



<li>Housekeeper – Stall Sweep/Easy – Menhammar Stuteri AB, Ekerö</li>



<li>Gourmet d’Arc – Gerrits Trading GmbH, Tyskland – Arcadia Allevamento S.S. Agricola</li>



<li>Global Good News – Ofcourse KB, Kovland – Global Farm AB, Nacka Strand</li>



<li>Västerbo Carretera – Edmond Graf &#038; A K Leitenroth – Västerbo Stuteri AB</li>
</ul>



<p class="has-text-align-center wp-block-paragraph">***</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/05/precioussteelmianilsson-617x333.jpg" alt="" class="wp-image-714020"/><figcaption class="wp-element-caption">Precious Steel. Foto Mia Nilsson</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">P<strong>recious Steel </strong>(e. Muscle Hill) kvalade in till Svensk Uppfödningslöpning i regi Dion Tesselaar, startade – och slutade fyra i finalen – under Peter Untersteiners vingar och tränas sedan dess av Johan Untersteiner.</p>



<p class="wp-block-paragraph">Det snabba stoet inledde årets säsong med seger i Margaretas Tidiga Unghästserie och efter finalplats i Breeders Course under Elitloppshelgen väntar ytterligare en stor final.</p>



<p class="wp-block-paragraph">Johan Untersteiner vet hur det känns att vinna långa E3 för ston. För tolv år sedan satt han bakom <strong>Mellby Briolett</strong> (e. Going Kronos), tränad av dåvarande arbetsgivaren Roger Walmann.</p>



<p class="has-text-align-center wp-block-paragraph">***</p>



<p class="has-drop-cap wp-block-paragraph">Roger Walmann toppar tränarligan i E3:s stoklass med sju vinnare sedan storloppet såg dagens ljus 1997. <strong>Tamla Celeber</strong> (e. Cantab Hall) och <strong>Giant Diablo</strong> (e. Supergill) vann dubbla finaler, medan <strong>Mellby Briolett</strong> (e. Going Kronos), <strong>Nursery Rhyme</strong> (e. Credit Winner) och  <strong>S.G.Empress</strong> (e. Readly Express) vann en upplaga.</p>



<p class="wp-block-paragraph">Tränarnestorn är med även i årets final, men den här gången slår han ut underläge. <strong>Housekeeper</strong> (e. Trixton) har tjänat näst minst av finalisterna och väntar på första årssegern.</p>



<p class="wp-block-paragraph">Detsamma gäller fältets fattigaste travare som också tränas av en norrman på svensk mark. Andreas Lövdal har plockat fram sin första unghästfinalist i Sverige genom <strong>Global Good News</strong> (e. S.J.’s Caviar).</p>



<p class="has-text-align-center wp-block-paragraph">***</p>



<p class="has-drop-cap wp-block-paragraph">Förutom Petri Salmela och Roger Walmann har ytterligare en av tränarna bakom årets finalister vunnit en E3-final för ston tidigare. Mattias Djuse tränade vinnaren av korta upplagan 2023: familjehästen <strong>A Teaser</strong> (e. Flocki d’Aurcy).</p>



<p class="wp-block-paragraph">I år mönstrar Solvallatränaren <strong>Whammy</strong> (e. Mosaique Face), som vann två av tre starter som tvååring, men väntar på att spräcka segernollan under årets säsong.</p>



<p class="has-text-align-center wp-block-paragraph">***</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/05/4gourmetdarc1-617x333.jpg" alt="" class="wp-image-723115"/><figcaption class="wp-element-caption">Gourmet d&#8217;Arc. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">När det gäller utlandsfödda vinnare av långa varianten av E3, så har segern gått till hästar födda utanför Sveriges gränser fyra gånger tidigare på 28 finaler. Tre segrar till Finland och en till Italien.</p>



<p class="wp-block-paragraph">I årets final kan Italien fördubbla segerskörden med nederländsk hjälp. Paul Hagoort har vunnit flera unghästlopp på svensk mark, men väntar på första E3-segern. Hoppet i stoklassen är <strong>Gourmet d’Arc</strong> (e. Six Pack), som har Robin Bakker i vagnen som vanligt.</p>



<p class="wp-block-paragraph">Gourmet d’Arc var obesegrad efter fem starter inför försöken – hon har vunnit Breeders Course-final både som två- och treåring – men fick se sig slagen i Gävle <strong>Global Got it All</strong> (e. Walner).</p>



<p class="wp-block-paragraph"><strong>Utlandsfödda vinnare i långa E3 för ston:</strong><br><em>År, vinnare (far) – Födelseland</em></p>



<ul class="wp-block-list">
<li>1999 Monkey Ride (e. Express Ride) – Finland</li>



<li>2014 Arctic Model (e. Classic Photo) – Finland</li>



<li>2017 Violet Bi (e. Equinox Bi) – Italien</li>



<li>2019 Mascate Match (e. Muscle Mass) – Finland</li>
</ul>



<p class="has-text-align-center wp-block-paragraph">***</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/05/vasterbocarretera2-617x333.jpg" alt="" class="wp-image-722850"/><figcaption class="wp-element-caption">Västerbo Carretera vinner för Rikard N Skoglund. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">Elva avelshingstar står bakom de tolv finalisterna och ensam om två chanser till vinsten har Readly Express, som är pappa till både <strong>Pure Stella</strong> och <strong>Kobra Brick</strong>. Readly Express har haft sju startande avkommor i E3-finalerna för ston och räknat in två vinnare. Red Lady Express vann långa upplagan för fyra år sedan och S.G.Empress tog hem korta E3 ifjol.<br>Även Muscle Hill (<strong>Princess Face</strong>) och Trixton (<strong>Barbro Kronos</strong>) har lämnat E3-vinnare i stoklassen tidigare.</p>



<p class="wp-block-paragraph">Däremot väntar Sveriges championhingst Maharajah på att spräcka nollan på stosidan. Hela 26 döttrar har kvalat in till finalerna, men det har blivit andraplatser som bäst. <strong>Västerbo Carretera</strong> är hans hopp på lördagen.</p>



<p class="wp-block-paragraph"><strong>Avelshingstar i E3 (hingstar/valacker): </strong><br><em>Avelshingst (finalist) – Tidigare finalister – Resultat</em></p>



<ul class="wp-block-list">
<li><strong>Maharajah</strong> (1) – 26 – Unstirred Drink* (3) 2016, Unstirred Drink** (6) 2016, Under the Counter* (0) 2016, White Lightning** (2) 2017, White Lightning* (3) 2017, Elektra** (0) 2017, Aleppo Pine** (3) 2018, Aleppo Pine* (0) 2018, I’m Sailing* (0) 2018, Base Line** (6) 2019, Malvha Ha* (2) 2020, Malvha Ha** (5) 2020, Nikita Sunrise** (6) 2020, Jes Angel** (0) 2020, Namanga Bo** (str) 2020, Florence Ima** (6) 2021, Amoa Queen** (0) 2021, One Night Only* (0) 2021, Eireann* (2) 2022, O’Mara Zon** (2) 2022, Kayla Westwood* (3) 2022, Caradja** (3) 2022, Lilian Young* (5) 2022, Caradja* (0) 2022, Esmeralda Bez* (0) 2023, Esmeralda Bez** (0) 2023</li>



<li><strong>Muscle Hill</strong> (1) – 8 – Sparkling Kronos** (0) 2014, <strong>Princess Face</strong>** (1) 2015, Hanna* (0) 2017, Twyla Face* (0) 2018, Bank Wise As* (4) 2020, Global Celebrity** (3) 2021, Mellby Kaxa* (0) 2022, Elegance Kronos* (4) 2023</li>



<li><strong>Nuncio</strong> (1) – 5 – Crazy Life** (4) 2022, Decision Maker** (0) 2022, Kinglet Bird** (3) 2023, Kinglet Bird** (5) 2023, Ready To Run H.C.** (5) 2024</li>



<li><strong>Readly Express</strong> (2) – 7 – Honey Mearas* (6) 2020, <strong>Red Lady Express</strong>* (1) 2021, Bright Crystal* (5) 2021, Lacille Boko* (0) 2021, Lacille Boko** (0) 2021, <strong>S.G. Empress</strong>** (1) 2024, S.G. Empress* (0) 2024</li>



<li><strong>S.J.’s Caviar</strong> (1) – 8 – Caviar’s Goldcard* (0) 2012, Caviar Sisu* (0) 2014, Staro Miami** (2) 2018, Staro Miami* (4) 2018, Global Allegiance* (2) 2019, Global Anarchy** (4) 2019, Global Anarchy* (0) 2019, Rihanna W.I.* (0) 2021</li>



<li><strong>Trixton</strong> (1) – 3 – Alaska Dany** (str) 2019, <strong>Barbro Kronos</strong>* (1) 2020, Loaded Maria* (0) 2020</li>



<li><strong>Walner</strong> (1) – 3 – Scarfo Pellini* (4) 2024, Captiva* (0) 2024, Scarfo Pellini** (0) 2024</li>



<li><strong>Bar Hopping</strong> (1), <strong>Makethemark</strong> (1), <strong>Mosaique Face</strong> (1) och <strong>Six Pack</strong> (1) har inte haft någon E3-finalist tidigare.</li>
</ul>



<p class="wp-block-paragraph">Fotnot: Deltog i *långa E3, **korta E3.<br><em>Makethemark har sin första kull treåringar på banan.</em></p>



<p class="has-text-align-center wp-block-paragraph">***</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/06/bonsseguardcjj-617x333.jpg" alt="" class="wp-image-736821"/><figcaption class="wp-element-caption">Bonsse Garde kommer ur Makethemarks första kull som avelshingst. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">Halva finalfältet har varit utbjudna på auktion. Den senaste gick upp i den digitala ringen så sent som i lördags när <strong>Global Genesis</strong> (e. Nuncio) efter andraplatsen i försöket bjöds ut på Travera. Där slogs klubban på 880.000 kronor.</p>



<p class="wp-block-paragraph">Dyrast av hästarna som ettåringar var <strong>Gourmet d’Arc</strong> (e. Six Pack), som såldes på italienska ITS-auktion för 31.000 euro. På svensk mark ropades <strong>Bonsse Garde</strong> (e. Makethemark) in för 190.000 kronor på Next Generation Sale.</p>



<p class="wp-block-paragraph"><strong>Så mycket kostade E3-finalisterna på auktion:</strong><br><em>Namn – Auktion – Pris</em></p>



<ul class="wp-block-list">
<li>Global Genesis* – Travera – 880.000 kr</li>



<li>Gourmet d’Arc – ITS Yearling – €31.000</li>



<li>Bonsse Garde – Next Generation Sale – 190.000 kr</li>



<li>Kobra Brick – Criterium Sale – 160.000 kr</li>



<li>House Keeper** – Menhammar Online – 100.000 kr</li>



<li>Västerbo Carretera – Next Generation Sale – 35.000 kr</li>
</ul>



<p class="wp-block-paragraph"><strong>Fotnot:</strong> Pure Stella var struken på Elitauktionen 2023.<br>* Global Genesis såldes den 21 juni i år på Travera.<br>** Housekeeper såldes under namnet Husan. </p>



<p class="has-text-align-center wp-block-paragraph">***</p>



<p class="has-drop-cap wp-block-paragraph">En miljon kronor är förstapriset i E3-finalen, men hela tio av tolv deltagare tävlar om ytterligare 50 procent i prispengar. Detta gäller hästar som är med i premiechansen, där upplägget gjordes om från och med kullen född 2022.</p>



<p class="wp-block-paragraph">Ägarna bakom <strong>Västerbo Carretera</strong> (e. Maharajah) valde att köra premielopp istället för att vara med i premiechansen och är en av två som inte kan få boostad prischeck. Den andra är utlandsfödd, italienska <strong>Gourmet d’Arc</strong> (e. Six Pack).</p>



<p class="wp-block-paragraph">Prissumma för premiechansade hästar:<br>1.500.000-750.000-375.000-180.000-120.000-75.000 kr</p>



<p class="wp-block-paragraph">Det är sjätte gången långa E3 för ston är med i premiechansen. Av de fem tidigare vinnarna har två inkasserat dubbla pengarna. 2022 blev det full pott för <strong>Sparven</strong> (e. Bird Parker) och ifjol fick <strong>Screen Time Limit</strong> (e. Face Time Bourbon) två miljoner kronor.</p>



<p class="has-text-align-center wp-block-paragraph">***</p>



<p class="wp-block-paragraph"><strong>Här är hästskötarna bakom årets finalister i långa E3:</strong><br><em>Finalist – Hästskötare</em></p>



<ol class="wp-block-list">
<li>Bonsse Garde – Fredrik Wallin</li>



<li>Pure Stella – Janina Soronen</li>



<li>Pure Athena – Matilda Bergström</li>



<li>Global Got It All – Matilda Bergström</li>



<li>Kobra Brick – Rebecca Nisonen</li>



<li>Global Genesis – Hugo Merayer</li>



<li>Precious Steel – Charlie Hillbom</li>



<li>Whammy – Ebba Janius</li>



<li>Housekeeper – Sofia Wedin</li>



<li>Gourmet d’Arc – Demi Veenstra</li>



<li>Global Good News – Lucas Carnemar</li>



<li>Västerbo Carretera – Camilla Svahn</li>
</ol>


<div class="factbox full ">
<div class="insidefactbox">
<div class="overflow">
<div class="height">
<div class="padding">
<div class="factvinjett">Fakta</div>
<h3 class="title">
									Vinnare av långa E3 ston								</h3>
<div class="content">
								<strong>År – Häst – Kusk – Tränare – Tid</strong></p>
<ul>
<li>1997 – <strong>Mack Action Ås</strong> – Örjan Kihlström – Olle Goop – 1.15,6a</li>
<li>1998 – <strong>Montana Chill</strong> – Erik Adielsson – Tomas Malmqvist – 1.16,3a</li>
<li>1999 – <strong>Monkey Ride</strong> – Tuomas Korvenoja – Tuomas Korvenoja – 1.15,1a</li>
<li>2000 – <strong>Ezamble</strong> – Erik Adielsson – Tommy Hanné – 1.14,5a</li>
<li>2001 – <strong>Pine Dust</strong> – Örjan Kihlström – Stefan Hultman – 1.15,5a</li>
<li>2002 – <strong>Rae Boko</strong> – Jorma Kontio – Markku Nieminen – 1.16,1a</li>
<li>2003 – <strong>Giant Diablo</strong> – Örjan Kihlström – Roger Walmann – 1.15,0a</li>
<li>2004 – <strong>Needles n’Pins</strong> – Lutfi Kolgjini – Lutfi Kolgjini – 1.14,7a</li>
<li>2005 – <strong>Joy Ås</strong> – Björn Goop – Olle Goop – 1.15,3a</li>
<li>2006 – <strong>Vala Boko</strong> – Jorma Kontio – Timo Nurmos – 1.14,2a</li>
<li>2007 –<strong> Lie Detector</strong> – Örjan Kihlström – Stefan Hultman – 1.16,5a</li>
<li>2008 – <strong>Mystical Ann</strong> – Åke Svanstedt – Åke Svanstedt – 1.15,4a</li>
<li>2009 – <strong>My Love di Quattro</strong> – Ulf Ohlsson – Petri Salmela – 1.13,5a</li>
<li>2010 – <strong>Tamla Celeber</strong> – Torbjörn Jansson – Roger Walmann – 1.14,1a</li>
<li>2011 – <strong>Britannia</strong> – Robert Bergh – Robert Bergh – 1.15,1a</li>
<li>2012 – <strong>System Performance</strong> – Stefan Melander – Stefan Melander – 1.14,1a</li>
<li>2013 – <strong>Mellby Briolett</strong> – Johan Untersteiner – Roger Walmann – 1.14,5a</li>
<li>2014 – <strong>Arctic Model</strong> – Pekka Korpi – Pekka Korpi – 1.13.9a</li>
<li>2015 – <strong>Timbal</strong> – Robert Bergh – Robert Bergh – 1.12,5a</li>
<li>2016 – <strong>Uncertain Age</strong> – Christoffer Eriksson – Tomas Malmqvist – 1.13,5a</li>
<li>2017 – <strong>Violet Bi</strong> – Jim Oscarsson – Jim Oscarsson – 1.13,7a</li>
<li>2018 – <strong>Zara Kronos</strong> – Joakim Lövgren – Joakim Lövgren – 1.12,7a</li>
<li>2019 – <strong>Mascate Match</strong> – Pekka Korpi – Pekka Korpi – 1.12,3a</li>
<li>2020 – <strong>Barbro Kronos</strong> – Erik Adielsson – Svante Båth – 1.13,8a</li>
<li>2021 – <strong>Red Lady Express</strong> – Carl Johan Jepson – Christian Persson – 1.12,6a</li>
<li>2022 – <strong>Sparven</strong> – Mika Forss – Jörgen Westholm – 1.13,6a</li>
<li>2023 – <strong>Coral Coger</strong> – Rikard N Skoglund – Ola Åsebö – 1.12,9a</li>
<li>2024 – <strong>Screen Time Limit</strong> – Ulf Ohlsson – Reijo Liljendahl – 1.13,3a</li>
</ul></div>
</p></div>
</p></div>
</p></div>
</p></div>
</p></div>



<figure class="wp-block-embed is-type-wp-embed is-provider-sulkysport wp-block-embed-sulkysport"><div class="wp-block-embed__wrapper">
<blockquote class="wp-embedded-content" data-secret="jp4LShB3Re"><a href="https://sulkysport.se/e3-h-v-redo-for-nya-stordad/">E3 h/v: Redo för nya stordåd!</a></blockquote><iframe class="wp-embedded-content" sandbox="allow-scripts" security="restricted" style="position: absolute; visibility: hidden;" title="”E3 h/v: Redo för nya stordåd!” &ndash; Sulkysport" src="https://sulkysport.se/e3-h-v-redo-for-nya-stordad/embed/#?secret=9BQek6EwJj#?secret=jp4LShB3Re" data-secret="jp4LShB3Re" width="500" height="282" frameborder="0" marginwidth="0" marginheight="0" scrolling="no"></iframe>
</div></figure>
