
<p class="has-drop-cap">Pensionerade Svante Båth är tränarkungen i E3 genom tiderna och enbart i hingst- och valackklassen tog han elva segrar! I årets final finns två tränar som vet hur man vinner E3.</p>



<p>Björn Goop slog till redan 2004 med <strong>Conny Nobell</strong> (e. Pearsall Hanover) som tog hem den korta upplagan.<br>I <strong>Grosbois</strong> (e. Maharajah) har Goop en ny segerstaplare, som dessutom tagit hem kullens största lopp hittills i år när han lekte hem finalen av Breeders Course på Elitloppsdagen. <br>– Grosbois har aldrig stuckit ut hemma, men på banan har han varit bra varje gång, sade Björn Goop efter finalsegern.</p>



<p>Den andre är Daniel Wäjersten, som fick sitt stora genombrott som tränare när han just på Bergsåker segrade i 2020 års upplaga av långa E3 med <strong>Global Badman</strong> (e. Yield Boko).<br>– Det har varit stor anspänning hela dagen och nu känns det mest tomt. Jag körde på säkerhet genom sista sväng och det var ingen strul under vägen. Den här vinsten kommer jag att komma ihåg länge, sade Wäjersten efter E3-triumfen.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/06/misternababdwadam-617x333.jpg" alt="" class="wp-image-866899"/><figcaption class="wp-element-caption">Mister Nabab och Daniel Wäjersten. Foto Adam Ström/Stalltz.se</figcaption></figure>



<p>Nyligen kom beskedet att tävlingskarriären är över för Global Badman, som ska leva pensionärsliv på Bjertorp dit Wäjerstens flyttlass går i slutet av året.<br>I årets final ställs hoppet till <strong>Mister Nabab</strong> (e. Mister J.P.), som ägs av franska travförbundets ordförande Jean-Pierre Barjon. Mister Nabab avslutade tvååringssäsongen med seger i tvååringsfinalen på Bergsåker och väntar på första årssegern 2026.</p>



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



<p>2.140 meter autostart, Bergsåker lördag<br><em>Häst (far) – Kusk (tränare)</em></p>



<ol class="wp-block-list">
<li><strong>City Slicker</strong> (e. King City) – Örjan Kihlström (Joakim Elfving)</li>



<li><strong>Neutron Star</strong> (e. Gimpanzee) – Claes Sjöström</li>



<li><strong>Reagan Boko</strong> (e. Chelsea Boko) – Robin Bakker (Paul Hagoort)</li>



<li><strong>Conrads Emil</strong> (e. In Range) – Jörgen S Eriksson</li>



<li><strong>Grosbois</strong> (e. Maharajah) – Björn Goop</li>



<li><strong>Raidhour Newport</strong> (e. Kadabra) – Finn Verkaik (Thomas Bos)</li>



<li><strong>Tennessee H.C. </strong>(e. Django Riff) – Per Lennartsson (Ville Karhulahti)</li>



<li><strong>In The Wind Gar</strong> (e. Captain Corey) – Mats E Djuse (Paul Hagoort)</li>



<li><strong>Zicken Zacke Zack</strong> (e. Maharajah) – Anders Zackrisson</li>



<li><strong>Intro</strong> (e. Readly Express) – Ulf Ohlsson (Björn Röcklinger)</li>



<li><strong>Steady Spender</strong> (e. Readly Express) – Magnus A Djuse (Eric Martinsson)</li>



<li><strong>Mister Nabab</strong> (e. Mister J.P.) – Daniel Wäjersten</li>
</ol>



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



<p class="has-drop-cap">Löpningsserien E3 firar jubileum och avgörs för 30:e gången. Historien om E3 tog sin början vid ett strategimöte på en Ålandsfärja 1995. Då hade de etablerade insatsloppen Stora Treåringspriset och Färjestads Nordiska Treåringspris tappat i attraktionskraft, och behovet av en ny satsning för treåringar var tydligt.</p>



<p>Under mötet lades grunden för det som skulle bli E3. Arrangörsbanorna enades om att skapa ett nytt insatslopp med bredare upptagningsområde och högre attraktionskraft. Vid ett pressmöte i december 1995 presenterades grundidéerna med långa och korta E3 samt höstens E3-Revanscher. Från början var samtliga lopp öppna för hästar födda i Europa.</p>



<p>Under de tre decennier som följt har serien fortsatt att utvecklas. Sedan 2011 är prispengarna lika stora för ston som för hingstar och valacker.</p>



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



<p class="has-drop-cap">Premiärvinnare på hingstsidan var <strong>Jolly Rocket</strong> (e. Atas Rocket) – tränad och körd av Per Lennartsson – som senare under sommaren även vann den korta upplagan. Lennartsson har även vunnit som kusk med <strong>Staro Azazell</strong> (e. Running Sea) och <strong>Red Hot Dynamite</strong> (e. Enjoy Lavec) i killarnas klass.<br>I år är Lennartsson anlitad som kusk bakom Ville Karhulahti-tränade <strong>Tennessee H.C. </strong>(e. Django Riff).</p>



<p>Förutom Lennartsson har Örjan Kihlström, Björn Goop, Ulf Ohlsson och Daniel Wäjersten av årets finalkuskar vunnit tidigare.</p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/06/neutronstarcsgk-617x390.jpg" alt="" class="wp-image-866986"/><figcaption class="wp-element-caption">Neutron Star och Claes Sjöström. Foto Gunilla König/Stalltz.se</figcaption></figure>



<p class="has-drop-cap">Snabbast av försöksvinnarna var <strong>Neutron Star</strong> (e. Chelsea Boko) för Claes Sjöström på 1.12,8a/2.100 meter och Sjöström vann också som gästkusk bakom Joakim Elfvings <strong>City Slicker</strong> (e. King City).</p>



<p>Den sistnämnde får Örjan Kihlström i vagnen, Örjan som tagit hem sju finaler för hingstar och valacker och där triumfen <strong>Maharajah</strong> (e. Viking Kronos) 2008 förstås sticker ut. Den insatsen på Bergsåker gjorde Kihlström rörd till tårar.</p>



<p><strong>Här är vinnarna: </strong></p>



<ul class="wp-block-list">
<li>Neutron Star (e. Gimpanzee) – Claes Sjöström – 1.12,8a</li>



<li>Reagan Boko (e. Chelsea Boko) – Robin Bakker – 1.13,0a</li>



<li>Grosbois (e. Maharajah) – Björn Goop – 1.13,4a</li>



<li>City Slicker (e. King City) – Claes Sjöström – 1.13,5a</li>



<li>Conrads Emil (e. In Range) – Jörgen S Eriksson – 1.13,5a</li>
</ul>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/11/reaganbokomalgang-617x411.jpg" alt="" class="wp-image-790197"/><figcaption class="wp-element-caption">Reagan Boko går enkelt undan till seger för Robin Bakker i försök till Svensk Uppfödningslöpning. Foto: Mikael Rosenquist/MiRo Media</figcaption></figure>



<p class="has-drop-cap">Finalisterna i E3 har gjort 100 starter tillsammans, vunnit 35 lopp och tjänat 8.166.991 kronor. Fyra av dem är miljonärer; <strong>City Slicker</strong> (1.376.188 kr), <strong>Grosbois</strong> (1.295.000 kr), <strong>Neutron Star</strong> (1.279.000 kr) och <strong>Reagan Boko</strong> (1.221.272 kr).</p>



<p>Allra flest starter har <strong>Tennessee H.C.</strong> (15) gjort och tvåsiffrigt antal lopp har också <strong>Zicken Zacke Zack</strong> (13) och <strong>Neutron Star</strong> (11).<br>Minst rutin har Björn Röcklingers ämne <strong>Intro</strong>, som debuterade den 1 maj och hittills har hunnit med fyra starter med två segrar och två andrapris som resultat.</p>



<p>Snitthästen har gjort 8,33 starter, vunnit 2,92 lopp och tjänat 680.582 kronor. Närmast den summan ligger <strong>Conrads Emil</strong> med 691.500 kronor. Han har vunnit fem lopp och det är han bäst på tillsammans med City Slicker. <br>Ifjol hade snitthästen tjänat 736.231 kronor, startat 8,67 gånger och vunnit 3,87 lopp. </p>



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



<p class="has-drop-cap">Ensam om staket i resultatraden är Jörgen S Erikssons auktionsfynd <strong>Conrads Emil</strong> (e. In Range). Efter galopp i debuten som tvååring och i årets första start i år (tvåa) har det blivit idel segrar för treåringen.<br>Jörgen har haft en finalist tidigare i <strong>Frazze</strong> (e. Mosaique Face), som slutade oplacerad 2022.</p>



<p>Sin andra finalist i E3 har också Anders Zackrisson. <strong>Devil Sound</strong> (e. Maharajah) var först ut 2018, då han slutade femma i korta finalen. I år mönstrar Zackrisson <strong>Zicken Zacke Zack</strong> (e. Maharajah).</p>



<p>För Axevallatränaren Eric Martinsson är det premiär i finalsammanhang när han startar <strong>Steady Spender</strong> (e. Readly Express). Detsamma gäller Ville Karhulahti (<strong>Tennessee H.C.</strong> e. Django Riff) och Björn Röcklinger (<strong>Intro</strong> e. Readly Express).</p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/10/cityslickerbg251019o-617x333.jpg" alt="" class="wp-image-783180"/><figcaption class="wp-element-caption">Joakim Elfving-tränade City Slicker och Björn Goop vann Svampen i Örebro. Foto Gunilla König/Stalltz.se</figcaption></figure>



<p class="has-drop-cap">Flera av finalisterna har tampats i storloppsammanhang tidigare. Största triumfen har <strong>Grosbois</strong> när han tog hem finalen i Breeders Course (Treåringseliten) under Elitloppshelgen med en miljon kronor till vinnaren.</p>



<p>Både <strong>Reagan Boko</strong> och <strong>City Slicker</strong> har vunnit Grupp II-lopp som tvååringar i Breeders Course (500.000 kr) respektive Svampen (482.938 kr).</p>



<p>Breeders Course-finalen på Elitloppsdagen har bara körts sedan 2019 och av de sju första vinnarna har <strong>Aetos Kronos</strong> (e. Bold Eagle) och ifjol <strong>Wise Guy</strong> (e. Face Time Bourbon) gått vidare och vunnit långa E3 några veckor senare. I år har Grosbois chansen att göra duon sällskap.</p>



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



<p class="has-drop-cap">Claes Sjöström-tränade <strong>Neutron Star</strong> (e. Gimpanzee) drog in 600.000 kronor som tvåa i Svensk Uppfödningslöpning bakom <strong>Tanja Tooma</strong>. Han vann även Vinterfavoriten under debutsäsongen.</p>



<p>Solvallatränaren har haft en handfull finalister på hingstsidan genom åren och närmast full pott var han 2018 när <strong>Jaguar Dream</strong> (e. Love You) slutade tvåa bakom <strong>Betting Gangster</strong> (e. Going Kronos) i korta upplagan i Gävle.</p>



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



<p class="has-drop-cap">Fyra avelshingstar har haft E3-finalister tidigare och en av dem har haft en vinnare. Maharajah-sonen Dream Mine vann långa E3 2024. I år har Maharajah dubbla chanser till seger genom <strong>Grosbois</strong> och <strong>Zicken Zacke Zack</strong>. <br>Två chanser till seger har också Readly Express genom <strong>Intro</strong> och <strong>Steady Spender</strong>. </p>



<p><strong>Avelshingstarna i E3 för h/v</strong><br><em>Avelshingst (finalister 2026) – Antal tidigare finalister</em></p>



<ul class="wp-block-list">
<li><strong>Kadabra</strong> (1) – 2 – Harmi’s Frido* (0) 2013, McSpirit** (0) 2016</li>



<li><strong>Maharajah</strong> (2) – 11 – Makethemark* (3) 2016, Makethemark** (2) 2016, Algot Zonett* (0) 2016, Devil Sound** (5) 2018, Marre’s Dreamboy** (6) 2020, Selected News* (str) 2020, Dowhatyoudodowell** (3) 2021, Donizetti* (0) 2021, <strong>Dream Mine*</strong> (1) 2024, Hiram* (3) 2025, Hirmam** (0) 2025</li>



<li><strong>Readly Express</strong> (2) – 10 – Despot Power* (2) 2020, Maestro Zon* (4) 2020, Revelation* (str) 2020, Cool Kronos* (0) 2021, Flotilla* (0) 2023, Phantom Express* (2) 2024, Bullet the Bluesky** (4) 2024, Pele Boko* (5) 2025, Zarex* (0) 2025, Zarex** (0) 2025.</li>
</ul>



<p>Captain Corey (1) har sin första kull ute på travbanan i år. Chelsea Boko (1), Django Riff (1), Gimpanzee (1), In Range (1), King City (1) och Mister J.P. (1) har sin första avkomma till start i E3-final.</p>



<p><strong>Fotnot: </strong>Deltog i *långa E3, **korta E3.</p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/06/introuoadam-617x333.jpg" alt="" class="wp-image-867023"/><figcaption class="wp-element-caption">Björn Röcklinger-tränade Intro och Ulf Ohlsson. Foto Adam Ström/Stalltz.se</figcaption></figure>



<p class="has-drop-cap">Sex av finalisterna i långa E3-finalen har sålts på auktion och allra mest betaldes det för Intro när han såldes på Menhammar Online för 650.000 kronor. Enda finalisten med utländskt pass – <strong>In the Wind Gar</strong> – såldes på ITS Yearling Sale för 24.000 euro. </p>



<p>Några andra av hästarna har också bjudits ut till försäljning på olika auktioner. <strong>Steady Spender</strong> ropades åter för 160.000 kronor på Åby Yearling Sale. <strong>Reagan Boko</strong> togs tillbaka för 120.000 kronor på Elitauktionen. <strong>Tennessee H.C.</strong> ropades åter för 22.000 kronor på Åby Yearling Sale. <strong>Raidhour Newport</strong> togs tillbaka för 270.000 kronor på Travera den 27 maj i år.</p>



<p><strong>Auktionspriser:</strong><br><em>Häst – Auktion – Pris</em></p>



<ul class="wp-block-list">
<li>Intro – Menhammar Online – 650.000 kr</li>



<li>Neutron Star – Solvalla Yearling Sale – 480.000 kr</li>



<li>In the Wind Gar – ITS Yearling Sale – €24.000</li>



<li>Grosbois – Elitauktionen – 240.000 kr</li>



<li>Conrads Emil – Elitauktionen – 100.000 kr</li>



<li>Tennessee H.C. – Travera – 22.000 kr</li>
</ul>



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



<p class="has-drop-cap">John Bootsman driver sin uppfödning genom nederländska bolaget Boko Stables Holland BV. Under svensk flagg blev det Boko-segrar för <strong>Chelsea Boko</strong> (e. Chocolatier) och <strong>Amaru Boko</strong> (e. Coktail Jet), som båda tog hem långa upplagan.<br>I årets final är Bootsmans bidrag <strong>Reagan Boko</strong> – med tidigare vinnaren Chelsea Boko som pappa.</p>



<p>Av finalisterna ägs eller delägs <strong>City Slicker, Raidhour Newport, Zicken Zacke Zack</strong> och <strong>Mister Nabab</strong> fortsatt av sin uppfödare.</p>



<p><strong>Uppfödarna bakom E3-finalisterna:</strong></p>



<ul class="wp-block-list">
<li>City Slicker – AB Svensk Reklamfinans, Halmstad</li>



<li>Neutron Star – Stall Courant AB, Heby</li>



<li>Reagan Boko – Boko Stables Holland BV, Nederländerna</li>



<li>Conrads Emil – Daniel Johansson, Mariannelund</li>



<li>Grosbois – Johan Arkland &#038; Jim Oscarsson </li>



<li>Raidhour Newport – Newport Breeding B.V, Nederländerna</li>



<li>Tennessee H.C. – Henrik &#038; Carina Caster </li>



<li>In The Wind Gar – Allev. Garigliano S.R.L., Italien</li>



<li>Zicken Zacke Zack – Anders Zackrisson, Kalmar</li>



<li>Intro – Annemanna AB, Ekerö</li>



<li>Steady Spender – Lars &#038; Anna Katarina Melin </li>



<li>Mister Nabab – Haras de la Source et des Chenes, Frankrike</li>
</ul>



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



<p class="has-drop-cap">Tre av morfäderna i årets final har tidigare haft vinnare. Cantab Hall och Pine Chip kan stoltsera med två vinnare vardera. Förstnämnde Cantab Hall står bakom <strong>Following</strong> (2022) och <strong>Far Wise As</strong> (2024), medan Pine Chips vinnare <strong>Going Kronos</strong> (2006) och <strong>Rolling Stones</strong> (2013) är betydligt längre tillbaka i tiden.</p>



<p>Maharajah hade en vinnare ifjol som morfar och då vann <strong>Nightlife In</strong>. </p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/06/cityslickercsgk-617x333.jpg" alt="" class="wp-image-866426"/><figcaption class="wp-element-caption">Joakim Elfving-tränade City Slicker håller undan i försöket. Foto Gunilla König/Stalltz.se</figcaption></figure>



<p class="has-drop-cap">Hårdsatsande hästägaren, hingstägaren och uppfödaren Lennart Ågren har genom sitt stall SRF Stable fått se två hästar vinna den här klassen. <strong>Heavy Sound</strong> (e. Ken Warkentin) slog till i korta upplagan 2015 och <strong>Bedazzled Sox</strong> (e. Brillantissime) vann över medeldistans för fyra år sedan.</p>



<p>Nu ställer Ågren hoppet till egna uppfödningen <strong>City Slicker</strong> (e. King City), som vann sitt försök. Som tvååring vann hästen Svampen.</p>



<p>På tal om tidigare vinnare. Rolf Anderssons Bro Byggnads AB var med och ägde 2012 års vinnare i långa finalen, <strong>Chelsea Boko</strong> (e. Chocolatier). Samme hingst är pappa till Rolf Anderssons bidrag i årets final: <strong>Reagan Boko</strong>!</p>



<p><strong>Hästägarna bakom E3-finalisterna:</strong></p>



<ul class="wp-block-list">
<li>City Slicker – SRF Stable</li>



<li>Neutron Star – Uppsala Handelshus AB, med flera</li>



<li>Reagan Boko – Bro Byggnads AB, Stockholm</li>



<li>Conrads Emil – Leejs Foder AB, Rosersberg</li>



<li>Grosbois – Hjelte Restaurang AB, Karlstad</li>



<li>Raidhour Newport – Newport Breeding B.V, Nederländerna</li>



<li>Tennessee H.C. – Fjellström Häst AB, med flera (V Karhulahti)</li>



<li>In The Wind Gar – Dragon Trotters B.V., Nederländerna</li>



<li>Zicken Zacke Zack – Anders Zakrisson AB &#038; Bengt Wedin HB</li>



<li>Intro – Hypnotic AB, Järfälla</li>



<li>Steady Spender – Lilla Edets Maskinuthyrning AB</li>



<li>Mister Nabab – Ecurie Jean-Pierre Barjon, Frankrike</li>
</ul>



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



<p class="has-drop-cap">E3 ingår i premiechansen och det är inte längre är dubbla förstapriset utan ”bara” 50 procent extra för de hästar som ingår i premiechansningen. Samtliga är med utom italienske In the Wind Gar. </p>



<p>Så här fördelas prispengarna:</p>



<p><strong>Premiechansen:</strong> 1.500.000-1.000.000-500.000-240.000-160.000-100.000 kr<br><strong>Icke premiechansade:</strong> 1.000.000-500.000-250.000-120.000-80.000-50.000 kr</p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/06/conradsemilskotare-617x592.jpg" alt="" class="wp-image-867021"/><figcaption class="wp-element-caption">Wiktoria Kopec sköter Conrads Emil. Foto Gunilla König/Stalltz.se</figcaption></figure>



<p><strong>Elva kvinnor och tränaren Thomas Bos. Det är skötarna bakom finalisterna.</strong><br><strong>Hästskötarna bakom E3-finalisterna:</strong></p>



<ul class="wp-block-list">
<li>City Slicker – My Hedberg</li>



<li>Neutron Star – Sara Norrström</li>



<li>Reagan Boko – Nicole Hendriks</li>



<li>Conrads Emil – Wiktoria Kopec</li>



<li>Grosbois – Annie Olsson</li>



<li>Raidhour Newport – Thomas Bos</li>



<li>Tennessee H.C. – Sakari Talikka</li>



<li>In The Wind Gar – Kim Hagoort</li>



<li>Zicken Zacke Zack – Paulina Hecht Hemmingsson</li>



<li>Intro – Linda Bergqvist</li>



<li>Steady Spender – Malin Martinsson</li>



<li>Mister Nabab – Charlotte Andersson</li>
</ul>
