
<p class="has-drop-cap wp-block-paragraph">1 En kvalfylld afton väntar i <strong>Örebro</strong> (första start 18.20) ikväll och 54 förhoppningsfulla tränare plockar ut hästar i de tio uttagningsloppen till årets första E3-finaler över medeldistans. Den avgörs på Bergsåker den 27 juni med en miljon kronor – plus 50 procent extra för premiechansade treåringar – i förstapris.</p>



<p class="wp-block-paragraph">54 tränare står bakom de 88 hästarna i uttagningsloppen och flest av alla har trion <strong>Johan Untersteiner</strong>, <strong>Roger Walmann</strong> och <strong>Daniel Wäjersten</strong> med fem hästar vardera.</p>



<h2 class="wp-block-heading">Tränare med tre eller fler hästar i E3-kvalen:</h2>



<ul class="wp-block-list">
<li>Johan Untersteiner, Halmstad – 5</li>



<li>Roger Walmann, Solvalla – 5</li>



<li>Daniel Wäjersten, Bergsåker – 5</li>



<li>Mattias Djuse, Solvalla – 4</li>



<li>Paul Hagoort, Solvalla – 4</li>



<li>Joakim Elfving, Romme – 3</li>



<li>Adrian Kolgjini, Jägersro – 3</li>



<li>Fredrik Wallin, Gävle – 3</li>
</ul>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2026/06/15v64.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till E3-kvalen i Örebro ikväll.</a></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/2026/06/grosboisledning-617x333.jpg" alt="" class="wp-image-860063"/><figcaption class="wp-element-caption">Grosbois och Björn Goop. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">2 På den fyrbenta sidan är det en häst som sticker ut. Björn Goops unghäststjärna <strong>Grosbois</strong> (e. Maharajah) har tagit tre segrar på fem starter och slog in en miljon i finalen av Breeders Course på Elitloppsdagen på topptiden 1.11,2a/2.140 meter. Noteringen var bara en tiondel långsammare än Wise Guys (e. Face Time Bourbon) världsrekordnotering från 2025.</p>



<p class="wp-block-paragraph">– Vi satsar mycket på unghästar och det är kul när det blir bra. Grosbois har aldrig stuckit ut hemma, men på banan har han varit bra varje gång, sade Björn Goop efter triumfen på Solvalla.</p>



<p class="wp-block-paragraph">Tränare Goop är själv avstängd ikväll sedan han inte fått gehör för sin överklagan av domen för dålig anslutning bakom startbilen bakom finske Pro i Elitkampen på kallblod på Elitloppsdagen.</p>



<p class="wp-block-paragraph">Han har två hästar i kvalen, där den andra är stoet <strong>Thai Medina</strong> (e. Face Time Bourbon), som vunnit båda sina starter i karriären. Per Linderoth hoppar upp i sulkyn bakom båda Gopp-hästarna.</p>



<p class="wp-block-paragraph">Det finns fler starka namn i startlistorna, framför allt på hingst- och valacksidan.</p>



<p class="wp-block-paragraph">Joakim Elfvings <strong>City Slicker</strong> (e. King City) har vunnit fyra av åtta starter, däribland Svampen och Breeders Crown som tvååring, samt Vårfavoriten i år.</p>



<p class="wp-block-paragraph">Claes Sjöströms <strong>Neutron Star</strong> (e. Gimpanzee) vann tre av fem starter som tvååring – däribland Vinterfavoriten – och slutade tvåa i Svensk Uppfödningslöpning. </p>



<p class="wp-block-paragraph">Paul Hagoorts <strong>Reagan Boko</strong> (e. Chelsea Boko) har vunnit tre av sex starter med största segern i Breeders Course-finalen för tvååringar och var även trea i Svensk Uppfödningslöpning och fyra i Breeders Course-finalen på Solvalla nyligen.</p>



<p class="wp-block-paragraph">Inget av de 46 stona har ännu nått sjusiffrig prissumma. Claes Sjöströms <strong>Royaute Boko</strong> (e. Brillantissime) är närmast med 724.000 kronor på kontot efter främst segern i ASVT:s auktionslopp som tvååring.</p>



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



<p class="has-drop-cap wp-block-paragraph">3 Travveckan inleds på – numera – sommarbanan <strong>Solänget</strong> (första start 12.20), som efter att ha mjukstartat säsongen på nationaldagen med breddlopp nu har ”vanliga” lopp på menyn till lunch.</p>



<p class="wp-block-paragraph">Solänget tävlar tio gånger i sommar och häst och säsongen avslutas den 13 oktober. Godbiten kommer onsdag den 8 juli då sommartravet kommer på besök och banans höjdare Silverörnen är det största loppet.</p>



<p class="wp-block-paragraph">Dagens lunch då? Av 76 startande hästar har Jan-Olov Perssons fyraåring <strong>Stjärnmode</strong> (e. Art Kjarvald) lyckats bäst under 2026. Tre segrar har det blivit under året, men nu har hästen gjort bort sig med galopp två starter i rad. Dags att bryta den sviten och starta en ny segerrad istället tillsammans med Marcus Lilius?</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2026/06/260615.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till dagens tävlingar.</a></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/12/superchaptermmmp250730adamstromstalltz-617x461.jpg" alt="" class="wp-image-805377"/><figcaption class="wp-element-caption">Marcus Melander. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">4 Marcus Melander har haft en fantastisk helg på andra sidan Atlanten och tagit fem storloppsvinster på två dagar och även räknat in ett världsrekord för <a href="https://sulkysport.se/fyrtal-for-melander-3/" data-type="link" data-id="https://sulkysport.se/fyrtal-for-melander-3/" target="_blank" rel="noreferrer noopener">Nix Nacken</a>.</p>



<p class="wp-block-paragraph">På 14 starter blev det åtta vinster, en andraplats och tre tredjepris. Totalt bokförde sig stallet för 561.542 dollar, eller 5,3 miljoner i svensk valuta.</p>



<p class="wp-block-paragraph"><strong>Här är storloppsvinnarna på Meadowlands, Mohawk och Vernon Downs:</strong></p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/dubbla-storlopp-till-melander/" data-type="link" data-id="https://sulkysport.se/dubbla-storlopp-till-melander/" target="_blank" rel="noreferrer noopener">Neighver Punt</a> – Goodtimes (C$240.000)<br><a href="https://sulkysport.se/fyrtal-for-melander-3/" data-type="link" data-id="https://sulkysport.se/fyrtal-for-melander-3/" target="_blank" rel="noreferrer noopener">Apex</a> – New Jersey Sire Stakes ($225.000)<br><a href="https://sulkysport.se/dubbla-storlopp-till-melander/" data-type="link" data-id="https://sulkysport.se/dubbla-storlopp-till-melander/" target="_blank" rel="noreferrer noopener">Bourbonista </a>– Armbro Flight (C$215.000)<br><a href="https://sulkysport.se/storseger-till-svenskfodd/" data-type="link" data-id="https://sulkysport.se/storseger-till-svenskfodd/" target="_blank" rel="noreferrer noopener">Nezuko Kamado</a> – Empire Breeders Classic ($195.020)<br><a href="https://sulkysport.se/fjarde-raka-for-spencer/" data-type="link" data-id="https://sulkysport.se/fjarde-raka-for-spencer/" target="_blank" rel="noreferrer noopener">Spencer Hanover</a> – Empire Breeders Classic ($176.530)</p>



<figure class="wp-block-image size-sulky-mellan2 is-resized"><img src="https://sulkysport.se/wp-content/uploads/2026/06/apex1262026lisa-617x346.jpg" alt="" class="wp-image-861580" style="width:524px;height:auto"/><figcaption class="wp-element-caption">Apex och Dexter Dunn tog hem finalen i New Jersey Sire Stakes. Foto: Lisa Photo</figcaption></figure>



<p class="wp-block-paragraph">31 segrar på 96 starter och 1,4 miljoner dollar inkört är facit för Marcus Melanders stall så här långt under 2026, vilket kan jämföras med ligaledaren Ron Burkes siffror som berättar att hans hästar gjort 2.022 starter, vunnit 416 lopp och tjänat 7,1 miljoner dollar!</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/2026/05/6idaodetillardefterat-617x333.jpg" alt="" class="wp-image-856501"/><figcaption class="wp-element-caption">Idao de Tillard efter Elitloppsförsöket. Foto: Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">5 Två av Elitloppsfavoriterna – och -finalisterna – och ytterligare två utländska deltagare i årets upplaga av sprinterloppet på Solvalla är på gång mot nya starter och denna gång handlar det om tävling i hemlandet Frankrike.</p>


<div class="factbox left minify">
<div class="insidefactbox">
<div class="overflow">
<div class="height">
<div class="padding">
<div class="factvinjett">Fakta</div>
<h3 class="title">
									Anmälda hästar till Prix Rene Balliere 2026								</h3>
<div class="content">
<p class="wp-block-paragraph">Idao de Tillard<br />Hooker Berry<br />Inexess Bleu<br />Koctel du Dain<br />Ino du Lupin<br />Fulton<br />Krack Time Atout<br />Ibiki de Houelle<br />Horchestro<br />Kapaula de l&#8217;Epine<br />Free Time Jepson<br />Keep Going<br />Jabalpur<br />Hannibal Tuilerie<br />Hulysse Diego<br />Cobra Killer Gar<br />Harmony du Rabutin<br />Fiftyfour<br />Hidalgo des Noes<br />Jazzman Debailleul<br />Kanto Avis<br />Isofou du Chene<br />Ibiscus Man<br />Kobayashi<br />Indus Val<br />Femto de Vauvert<br />Indy Dark<br />Helios Si<br />Rikita JP<br />General du Nord<br />Lasko des Brousses<br />Oblivion<br />Gioiello Roc</p>
</p></div>
</p></div>
</p></div>
</p></div>
<div class="expand">
						<span class="text">Expandera</span><br />
						<span class="icon sprites"></span>
					</div>
</p></div>
</p></div>



<p class="wp-block-paragraph">På söndag körs sommaren stora &#8221;snabblopp&#8221; <strong>Prix Rene Balliere</strong> (€200.000) på Vincennes och det är en maffig tävlingsdag Parisbanan bjuder på även vid sidan om loppet för den äldre eliten. På programmet står bland annat montéloppen <strong>Prix de Normandie</strong> (€240.000) för femåringar och <strong>Prix President Republique</strong> (€240.000) för fyraåringar. </p>



<p class="wp-block-paragraph"><strong>Idao de Tillard </strong>(e. Severino), <strong>Inexess Bleu</strong> (e. Vittel de Brevol), <strong>Jabalpur</strong> (e. Booster Winner) och <strong>Keep Going</strong> (e. Follow You) är alla intresserade av att vara med bakom bilen i söndagens Prix Rene Balliere och alla kommer efter en sejour i norra Europa, där de två förstnämnda tävlade två gånger samma dag.</p>



<h2 class="wp-block-heading">De tio senaste årens vinnare av Prix Rene Balliere</h2>



<figure class="wp-block-image alignright size-sulky-mellan2 is-resized"><img src="https://sulkysport.se/wp-content/uploads/2020/07/boldeaglemal22-617x333.jpg" alt="" class="wp-image-102800" style="width:446px;height:auto"/><figcaption class="wp-element-caption">Bold Eagle gillade att tävla på Vincennes under sommaren. <br>Foto Jeannie Hedlund/Sulkysport</figcaption></figure>



<ul class="wp-block-list">
<li>2016: <strong>Bold Eagle</strong> (e. Ready Cash) – Eric Raffin – 1.10,8a/2.100 meter</li>



<li>2017:<strong> Bold Eagle</strong> (e. Ready Cash) – Franck Nivard – 1.10,5a/2.100 meter</li>



<li>2018: <strong>Bold Eagle</strong> (e. Ready Cash) – Franck Nivard – 1.10,3a/2.100 meter</li>



<li>2019: <strong>Bold Eagle</strong> (e. Ready Cash) – Björn Goop – 1.10,2a/2.100 meter</li>



<li>2020: <strong>Face Time Bourbon</strong> (e. Ready Cash) – Björn Goop – 1.09,4a/2.100 meter</li>



<li>2021: <strong>Face Time Bourbon</strong> (e. Ready Cash) – Eric Raffin – 1.09,1a/2.100 meter</li>



<li>2022: <strong>Vivid Wise As</strong> (e. Yankee Glide) – Matthieu Abrivard – 1.09,1a/2.100 meter</li>



<li>2023: <strong>Hokkaido Jiel</strong> (e. Brillantissime) – David Thomain – 1.09,1a/2.100 meter</li>



<li>2024: <strong>Horsy Dream</strong> (e. Scipion du Goutier) – Eric Raffin – 1.09,2a/2.100 meter</li>



<li>2025: <strong>Jabalpur</strong> (e. Booster Winner) – Gabriele Gelormini – 1.08,7a/2.100 meter</li>
</ul>



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



<figure class="wp-block-image size-sulky-mellan2 is-resized"><img src="https://sulkysport.se/wp-content/uploads/2026/06/skarmavbild20260614kl.17.31.59-617x341.jpg" alt="" class="wp-image-861880" style="width:617px;height:auto"/><figcaption class="wp-element-caption">Odds On Mr Mamba hinner fram till seger längst ut i banan.</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">6 Woodbines stora kväll i lördags blev en framgångssaga för en långväga gäst från USA. Melanie Wrenn och hennes <strong>Odds On Mr Mamba</strong> (e. Odds On Equuleus) kunde efter en perfekt resa i andra ytter spurta till knapp vinst för James MacDonald när kvällens höjdpunkt Pepsi North America Cup (C$1.000.000) för treåriga passgångare stod på tur.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/06/skarmavbild20260614kl.17.35.38-617x340.jpg" alt="" class="wp-image-861881"/><figcaption class="wp-element-caption">Melanie Wrenn i förgrunden och James MacDonald där bakom.</figcaption></figure>



<p class="wp-block-paragraph">Melanie Wrenn tränar sina hästar i Indiana, USA och en gång tidigare hade hon gjort resan till Ontario och Toronto för ett deltagande i Pepsi North America Cup. Nu blev det full pott för tränaren som selade ut sin första häst som tränare för drygt fyra år sedan. Hennes första vinnare kom i slutet av mars 2022 och sedan dess har drygt 250 segrar lagts till kontot, detta på 1.400 starter.</p>



<p class="wp-block-paragraph">687,448 dollar spelades det för i Pepsi North America Cup, vilket är en högstanotering i loppets 43-åriga historia. Det tidigare omsättningsrekordet för loppet var 681,000 dollar från 2015.</p>



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



<p class="has-drop-cap wp-block-paragraph">7 Bergsåker är värd för E3- och STL-finaler lördagen den 27 juni och de divisionslopp som igår avgjordes på Bjerke är kvalificerande för just den finaldagen i Sundsvall. Däremot står kommande söndags V85-omgång-finaler att vänta på Solvalla den 19 augusti, vilket gäller för alla klasser utom gulddivisionen. Finalen av det meetinget är detsamma som Sundsvall Open Trot som avgörs på Bergsåker den 29 augusti.</p>



<p class="wp-block-paragraph">Så förutom kvällens finalister i E3-uttagningarna kan vi redan nu skönja vilka hästar som kommer att vara med i STL-finalerna på Bergsåker nästa vecka.</p>



<figure class="wp-block-image size-sulky-liten2 is-resized"><img src="https://sulkysport.se/wp-content/uploads/2026/06/skarmavbild20260614kl.21.14.33-350x235.png" alt="" class="wp-image-861923" style="aspect-ratio:1.4894217207334273;width:365px;height:auto"/><figcaption class="wp-element-caption">Tiberius Victory.</figcaption></figure>



<p class="wp-block-paragraph">Gårdagens två vinnare på Bjerke är klara för finalerna i Sundsvall och först ut av vinnarna igår var Andreas Lövdals <strong>Tiberius Victory</strong> (e. Face Time Bourbon), som från ledningen såg ut att ha det lätt hela vägen in mot mål när han vann klass I-försöket på 1.13,3a/2.100 meter.</p>



<p class="wp-block-paragraph">Paul Hagoorts <strong>Killer Rain</strong> (e. Face Time Bourbon) vann silverdivisionsförsöket på 1.09,9a/1.609 meter från dödens och lär väl tillhöra favoritskaran även över medeldistans när finalen går av stapeln nästa vecka.</p>



<h2 class="wp-block-heading">Vinnare i respektive klass</h2>



<p class="wp-block-paragraph"><strong>Klass III<br></strong>Puskas Boko<br>Last Cool Cash<br>Illuminato<br>R.K.Pascal</p>



<p class="wp-block-paragraph"><strong>Klass II<br></strong>Golden Kronos<br>Gretzky Brodde<br>Bourbon Crown<br>Maverick</p>



<figure class="wp-block-image size-sulky-mellan2 is-resized"><img src="https://sulkysport.se/wp-content/uploads/2026/06/skarmavbild20260613kl.22.30.26-617x327.jpg" alt="" class="wp-image-861671" style="width:326px;height:auto"/><figcaption class="wp-element-caption">Husavik och Sandra Eriksson.</figcaption></figure>



<p class="wp-block-paragraph"><strong>Klass I<br></strong>Husavik<br>Tiberius Victory<br>Global Evolution<br>Look At Me Sisu<br>Automatic Flight</p>



<figure class="wp-block-image size-sulky-mellan2 is-resized"><img src="https://sulkysport.se/wp-content/uploads/2025/05/6crowemotion1-617x333.jpg" alt="" class="wp-image-722985" style="width:332px;height:auto"/><figcaption class="wp-element-caption">Crowe Motion. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph"><strong>Bronsdivisionen<br></strong>Olli Boko<br>Crowe Motion</p>



<p class="wp-block-paragraph"><strong>Silverdivisionen</strong><br>Killer Rain<br>Ready Star<br>Nilla Lane<br>Poleposition</p>



<p class="wp-block-paragraph"><strong>Stodivisionen</strong><br>Sonesta<br>Treasure Tile<br>Rania Zon<br>Showtime Zon<br>Ditte Gel</p>



<figure class="wp-block-image size-sulky-mellan2 is-resized"><img src="https://sulkysport.se/wp-content/uploads/2026/06/skarmavbild20260606kl.16.38.41-617x380.jpg" alt="" class="wp-image-859190" style="aspect-ratio:1.6237704361983583;width:330px;height:auto"/><figcaption class="wp-element-caption">M.T. Tommorows Hope och Robert Bergh.</figcaption></figure>



<p class="wp-block-paragraph"><strong>Diamantstoet</strong><br>M.T.Tomorrows Hope<br>Havana Heaven</p>
