
<p class="has-drop-cap">1Fem år i rad från 2011 gav Sleipner Cup-finalen för fyraåriga kallblod svaret på vem som senare skulle vinna Svenskt Kallblodsderby. Så är det inte längre. Det är elva år sedan senaste gången det hände.<br>Ikväll på <strong>Romme</strong> (första start 18.30) kan i alla fall två fyraåriga kallblod sätta avtryck inför vad som komma skall när årets finaler avgörs med 150.000 kronor i varje i två fyllda 15-hästarsfält.</p>



<p>De största namnen i kullen saknas i finalerna. Med ett undantag i Jan Roar Mjölnerds sto <strong>Mjölner Tyra</strong> (e. Ängsborken), som var tvåa i Stokriteriet och Oaks i Norge och trea i svenska Kriterietstoet ifjol.<br>Stona har haft en egen klass sedan 2011 och från och med 2021 är dessutom prispengarna jämställda. Bara <strong>Majblomster</strong> (e. Tekno Odin) har följt upp seger i Sleipner Cup för ston med seger i Derbystoet senare samma sommar. Är det Mjölner Tyras tur nu?</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/05/majblomster1-617x333.jpg" alt="" class="wp-image-723548"/><figcaption class="wp-element-caption">Majblomster och Mats E Djuse. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p>På hingstsidan är det dukat för en duell mellan Jan-Olov Persson och Öystein Tjomsland, spetsat med en färsk amatörtränad storloppsvinnare.<br>Perssons och Tjomslands kort kommer med liknande förutsättningar till finalen. <strong>Järvsö Robert </strong>(e. Järvsö Elling) inledde karriären med fem raka segrar – varav tre som treåring före ett tio månader långt tävlingsuppehåll – har har sedan två raka silverplatser. <br>– Han är fin, han står 20 meters bättre till mot G.G. Xtrem som han fick stryk av senast. Det är en väldigt bra häst och eftersom han blev skadad ifjol har han inte tjänat så mycket pengar, sade Mats E Djuse till ATG Live.</p>



<p><strong>Grisle Balder G.L.</strong> (e. Grisle Odin G.L.) debuterade först i år och började med fyra raka segrar innan han blev tvåa i senaste starten.<br>– Han har utvecklats mycket och hade gått framåt rejält när jag körde honom näst senast. Han kan göra ett bra lopp, men jag tycker att det är tuffa hästar där bakom, sade Ulf Ohlsson till ATG Live.</p>



<p>Bakom dessa lurar Olov Brunlöfs <strong>G.G. Extrem</strong> (e. Grisle Odin G.L.), som inte är anmäld till de klassiska loppen. Ifjol vann han Hälsinglands Treåringspris och nu kommer han från triumfen i Prinsessan Madeleines Pokal tillsammans med Fredrik Plassen, som kör igen.</p>



<p><strong>Vinnare av Sleipner Cup/Svenskt Kallblodsderby:</strong></p>



<ul class="wp-block-list">
<li>2011 – <strong>Månprinsen A.M.</strong> (e. Svall Ivar)</li>



<li>2012 – <strong>Tekno Odin</strong> (e. Moe Odin)</li>



<li>2013 – <strong>Hellin Faxen</strong> (e. Järvsöfaks)</li>



<li>2014 – <strong>Lannem Silje</strong> (e. Åsajärven)</li>



<li>2015 – <strong>Järvsörappen</strong> (e. Järvsöfaks)</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/2026/05/likeabossuom260506adamstromstalltz-617x403.jpg" alt="" class="wp-image-847217"/><figcaption class="wp-element-caption">Likeaboss håller undan för Ulf Ohlsson. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p class="has-drop-cap">2 Sommartravet rullar vidare med en bana som tävlar onsdagskvällar och Romme bjuder på mer än finalerna för de fyraåriga kallbloden. Som ett fint försök i bronsdivisionen med en stor dalaprofil i startfältet.</p>



<p>Rättviksamatören Per Lindqvist har haft mycket tålamod och gjort ett stort arbete med krigaren <strong>Likeaboss</strong> (e. Brad de Veluwe), som kom tillbaka till tävlingsbanan i vintras efter tre års (!) skade- och sjukdomsuppehåll. Fem starter har slutat med tre segrar och två andrapris. Senast svarade han för en strong insats som tvåa från dödens på Solvalla tillsammans med Ulf Ohlsson.<br>– En jättefin häst och han gör alltid sist, han krigar till sista blodsdroppen. Han har fått ett bra läge, men är inte beroende av ledningen och visade senast att han kan gå utvändigt också, sade Ulf Ohlsson till ATG Live.</p>



<p>Likeaboss är anmäld barfota runt om för första gången i karriären.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2026/06/10v86.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till kvällens V86-omgång på Romme.</a></p>



<p><strong>––> Sulkysports expertpanel bjuder på sina bästa spikar och skrällbud till Rommes V86-omgång, som publiceras vid lunchtid.</strong></p>



<p><em>Vill du spela andelsspel tillsammans med Sulkysports panel? Här finns olika alternativ:</em></p>



<p><a href="https://www.atg.se/butik/simsalabim/V86_2026-06-10_23_3" target="_blank" rel="noreferrer noopener">Här finns andelar till V86 hos Simsalabim.</a></p>



<p><a href="https://www.atg.se/butik/69ansspel/V86_2026-06-10_23_3" target="_blank" rel="noreferrer noopener">Här finns andelar till V86 hos 69:ans Spel &#038; Tobak.</a></p>



<p><a href="https://www.atg.se/butik/spelpoolen/V86_2026-06-10_23_3" target="_blank" rel="noreferrer noopener">Här finns andelar till V86 hos Spelpoolen.</a></p>



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



<p class="has-drop-cap">3Det blir dubbla tävlingar på svensk mark idag när <strong>Jägersro</strong> (första start 12.20) bjuder på lunchtävlingar. Dit sänder Johan Untersteiner en av sina många spännande treåringar i form av tyskfödde <strong>Gauthier</strong> (e. Maharajah).<br>Treåringen, vars mamma <strong>Gamine Newport</strong> (e. Cantab Hall), 1.12,9a/$68.022, var tvåa i tyska Stoderbyt, gjorde ett starkt intryck i tävlingsdebuten i Kalmar för knappt tre veckor sedan när han triumferade på 1.15,6/2.140 meter.</p>



<p>Gauthier ställs mot en häst som verkligen har blickarna på sig. <strong>Nazario</strong> (e. Walner) är lillebror till Sveriges näst vinstrikaste sto genom tiderna, 26-faldiga miljonärskan <strong>Joviality.</strong> Nazario har varvat upp i jakten på livets första seger, Adrian Kolgjini kommer med två raka andraplatser till dagens start.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2026/06/260610.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till dagens tävlingar.</a></p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2021/07/facetomebourbonforni-617x333.jpg" alt="" class="wp-image-188957"/><figcaption class="wp-element-caption">Face Time Bourbon. Foto Gerard Forni</figcaption></figure>



<p class="has-drop-cap">4 <strong>Face Time Bourbon</strong> är fortsatt i topp bland avelshingstarna på fransk mark samtidigt som hans far Ready Cash klättrat upp ett pinnhål och är tvåa.</p>



<p>Tre avelshingstar har dragit in över två miljoner euro i Frankrike och förutom Face Time Bourbon och Ready Cash handlar det om Village Mystic.</p>



<p>Tre av Face Time Bourbons avkommor har vunnit lopp med minst 100.000 euro i prissumma: </p>



<ul class="wp-block-list">
<li>Prix de Centaures<strong> </strong>(€240.000) – <strong>Kobayashi</strong></li>



<li>Criterium des Jeunes (€200.000) – <strong>Nocive du Choquel</strong></li>



<li>Prix Gelinotte (€120.000) – <strong>Nocive du Choquel</strong></li>



<li>Prix du Luxembourg (€100.000) – <strong>Executiv Ek</strong></li>
</ul>



<p>Face Time Bourbon toppar också på tvååringssidan före Ready Cash och trea är Ready Cash-sonen Italiano Vero.</p>



<h2 class="wp-block-heading">Avelsstatistik Frankrike (alla åldrar)</h2>



<p><strong>Namn (far) – Starter – Segrar – Inkört (€)</strong></p>



<ol class="wp-block-list">
<li><strong>Face Time Bourbon</strong> (e. Ready Cash) – 624 – 78 – €2.464.580 (1)</li>



<li><strong>Ready Cash</strong> (e. Indy de Vive) – 623 – 75 – €2.194.310 (3)</li>



<li><strong>Village Mystic</strong> (e. Love You) – 540 – 50 – €2.010.180 (2)</li>



<li><strong>Booster Winner </strong>(e. Love You) – 784 – 75 – €1.853.590 (4)</li>



<li><strong>Royal Dream </strong>(e. Love You) – 546 – 70 – €1.783.105 (5)</li>



<li><strong>Love You </strong>(e. Coktail Jet) – 665 – 74 – €1.747.804 (7)</li>



<li><strong>Brillantissime</strong> (e. Ready Cash) – 536 – 50 – €1.516.795 (6)</li>



<li><strong>Dollar Macker </strong>(e. Saxo de Vandel) – 525 – 60 – €1.448.835 (9)</li>



<li><strong>Prodigious </strong>(e. Goetmals Wood) – 465 – 53 – €1.447.127 (ny)</li>



<li><strong>Bold Eagle </strong>(e. Ready Cash) – 511 – 46 – €1.357.310 (10)</li>
</ol>



<p><strong>Fotnot: ()</strong> placeringssiffra förra månaden.</p>



<h2 class="wp-block-heading">Treåringar</h2>



<p><strong>Namn (far) – Starter – Segrar – Inkört (€)</strong></p>



<ol class="wp-block-list">
<li><strong>Face Time Bourbon</strong> (e. Ready Cash) – 119 – 28 – €562.465</li>



<li><strong>Ready Cash </strong>(e. Indy de Vive) – 86 – 19 – €472.850</li>



<li><strong>Italiano Vero</strong> (e. Ready Cash) – 71 – 13 – €373.572</li>



<li><strong>Boccador de Simm</strong> (e. Rieussec) – 117 – 14 – €339.490</li>



<li><strong>Django Riff </strong>(e. Ready Cash) – 72 – 12 – €323.665</li>



<li><strong>Earl Simon </strong>(e. Prodigious) – 94 – 9 – €305.660</li>



<li><strong>Booster Winner </strong>(e. Love You) – 99 – 19 – €297.370</li>



<li><strong>Galius </strong>(e. Love You) – 73 – 19 – €291.750</li>



<li><strong>Impressionist </strong>(e. Ready Cash) – 124 – 10 – €274.860</li>



<li><strong>Carat Williams </strong>(e. Prodigious) – 77 – 14 – €243.135</li>
</ol>



<p><strong>Fotnot: </strong>siffrorna gäller per den 31 maj och starter på fransk mark.</p>



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



<p class="has-drop-cap">5 Knappt ett storlopp har gått Alessandro Gocciadoro förbi i Italien i år och på lördag kan han det vara dags för en ny femetta i Gran Premio Ivone Grassetto (€66.000) i Padova.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/03/rfr96810945840c209511f1ba76b4cd841b8920-617x411.jpg" alt="" class="wp-image-827694"/><figcaption class="wp-element-caption">Dany Capar vinner för Alessandro Gocciadoro och bakom slutar Banderas Bi tvåa. Foto: F Rosellini</figcaption></figure>



<p>Tre av hästarna selas ut från Alessandro Gocciadoros stall och för egen del sitter ”gul kusk” upp bakom <strong>Dany Capar</strong>, medan han lånar ut <strong>Click Bait</strong> till Federico Esposito och <strong>Dali Prav</strong> till Rene’ Legati.</p>



<p><strong>Gran Premio Ivone Grassetto</strong> (€66.000)<br>Äldre hästar.<br><em>1.640 meter, autostart.</em></p>



<p><strong>Namn (far) – Körsven</strong></p>



<ol class="wp-block-list">
<li><strong>Dana Ek </strong>(e. Vivid Wise As) – Pietro Gubellini</li>



<li><strong>Ernesto Spritz</strong> (e. Maharajah) – Andrea Farolfi</li>



<li><strong>Dylan Dog Font</strong> (e. Ringostarr Treb) – Roberto Vecchione</li>



<li><strong>Click Bait</strong> (e. Cantab Hall) – Federico Esposito</li>



<li><strong>Dubhe Prav </strong>(e. Robert Bi) – Santo Mollo)</li>



<li><strong>Firmanento St</strong> (e. Napoleon Bar) – Marco Stefani</li>



<li><strong>Dali Prav </strong>(e. Donato Hanover) – Rene’ Legati</li>



<li><strong>Flash Np </strong>(e. Owen Cr) – Ferdinando Pisacane</li>



<li><strong>Dany Capar</strong> (e. Exploit Caf) – Alessandro Gocciadoro</li>
</ol>



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



<p class="has-drop-cap">6 Virgil Morgan Jr. skrev historia i lördags när han tog sin 8.000:e seger som tränare. Jubileumsvinsten kom på hemmabanan Scioto Downs när Justin Irvine guidade passgångaren <strong>I Dit It Myway</strong> först över mål.</p>



<figure class="wp-block-image alignright size-sulky-liten2"><img src="https://sulkysport.se/wp-content/uploads/2026/06/virgilmorganinset0603-350x489.jpg" alt="" class="wp-image-859913"/><figcaption class="wp-element-caption">Virgil Morgan Jr. Foto: Mark Hall/USTA</figcaption></figure>



<p>I ett 31 år (!) har Virgil varit ledande tränare på Scioto Downs och för att nå 8.000 triumfer krävdes 35.695 starter. Totalt har hans hästar tjänat över 83 miljoner dollar. Sedan 1998 har stallet dragit in mer en miljon dollar varje år och bästa säsongen hade han 2024 med 5,3 miljoner dollar, medan högsta segerantalet – 409 – räknades in 2000.</p>



<p>Bara en tränare har fler segrar. Ron Burke toppar med 16.876 vinster, följd av Virgil Morgan Jr. och Ervin Miller med 7.060 segrar. </p>



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



<p class="has-drop-cap">7 I lördags fick ostartade <strong>Hail Boko</strong> (e. Chocolatier-Sue Boko) ett stoföl efter Fame and Glory hos Lotta Chaudet på Ecurie du Clair de Lune i Frankrike.</p>



<p>– Hail Boko går till Italiano Vero innan hon åker hem till Sverige och Dalarna, berättar Roger Åström.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/06/hailboko-617x823.jpg" alt="" class="wp-image-859888"/><figcaption class="wp-element-caption">Hail Bokos stoföl efter Fame and Glory. Foto: privat</figcaption></figure>



<p>Modern Hail Boko har tre startande avkommor efter S.J.’s Caviar och samtliga har varit ute och tävlat och tjänat sexsiffrigt. Vinstrikast är <strong>Global Feather</strong>, 1.11,9ak/321.026 kr, <strong>Global Go Bajen Go</strong>, 1.15,2am/187.900 kr, och <strong>Global Dice</strong>, 1.14,6am/158.650 kr.</p>



<p>Mormor <strong>Sue Boko</strong> (e. Yankee Glide), 1.12,3ak/834.216 kr, vann Treåringseliten och i avelsboxen är hon utsedd till ”Elitsto” efter ha lämnat <strong>Inti Boko</strong> (e. Chocolatier), 1.09,9ak/6.196.154 kr, <strong>Amaru Boko</strong> (e. Coktail Jet), 1.10,3ak*/4.370.093 kr, och <strong>Grant Boko </strong>(e. Ready Cash), 1.10,9ak/2.735.649 kr.</p>



<p>Ni vet väl att ni kan maila in fölrapporter för fri publicering? Uppge mor, far och kön på fölet. Skriv också om ni bestämt vilken hingst stoet ska gå till i år och skicka gärna med en bild tagen på bredden.<br><a href="mailto:claes@sulkysport.se">Maila till Sulkysport</a></p>
