
<p class="has-drop-cap wp-block-paragraph">1 Den ena vann Kriteriestoet i både Sverige och Norge, medan den andra tog hem Oaks i Norge när de svenskfödda treåriga tjejerna tog storslam i kullens största stolopp förra året.</p>



<p class="wp-block-paragraph">Ikväll på <strong>Bergsåker</strong> (första start 18.20) möts Jan-Olov Persson-tränade <strong>Hertiginnan Stöen</strong> (e. Tekno Odin) och Anders Wallins <strong>Björgen</strong> (e. Bork Odin) i ett av de sista försöken i fyaåringsserien Sleipner Cup med final på Romme om den dryg månad.</p>



<p class="wp-block-paragraph">Hertiginnan Stöen har gjort två starter i vår, men galopperat i båda, medan Björgen selas ut för årsdebut och första starten sedan triumfen i Oaks på Momarken i mitten av oktober. Stona startar från 60 meters tillägg i ett lopp som innehåller fler starka fyraåriga ston, som <strong>Hög Decibel </strong>(e. Art Kjarvald), <strong>Vårblomster </strong>(e. Ängsborken) och <strong>Mynta V.S.</strong> (e. Ängsborken) för att nämna en trio.</p>



<p class="wp-block-paragraph">Loppet är placerat utanför V64-kupongen på Bergsåker, där det bjuds en hel del grannlåt i övrigt.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2020/10/jobspost-617x460.jpg" alt="" class="wp-image-113781"/><figcaption class="wp-element-caption">Jobspost.</figcaption></figure>



<p class="wp-block-paragraph">Jörgen Westholms <strong>Jobspost</strong> (e. Readly Express) har imponerat stort sedan han kommit tillbaka lysande efter långt skadeuppehåll och genrepar inför bronsdivisionsfinalen under Elitloppshelgen i ett sprinterlopp. Jobspost tog hem två bronsförsök i april. Nu ställs han mot <strong>D’Apper</strong> (e. Walner), som vann försök i Sprintermästaren förra året och blandade höga toppar med djupare dalar under debutsäsongen på svensk mark.</p>



<p class="wp-block-paragraph">Bland nio startande hästar från hemmatränaren Daniel Wäjerstens stall finns den efter tre starter obesegrade fyraåringen <strong>Mellby Mowgli</strong> (e. Readly Express), som efter två vinster som treåring inledde årets säsong på bästa sätt.</p>



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



<p class="has-drop-cap wp-block-paragraph">2 Först ut på svensk mark är lunchbanan <strong>Vaggeryd</strong> (första start 12.20), dit Ulf Stenströmer bland annat reser med fyraårige <strong>Miyagi</strong> (e. Six Pack). Hästen har debuterat i år och inlett på fint sätt. Tre segrar och ytterligare tre pallplatser på åtta starter har det blivit så här långt. Nu har hästen dragit innerspår bakom bilen i dagens första lopp.</p>



<p class="wp-block-paragraph">Miyagi är en av fem svenskfödda hästar i <strong>Six Packs</strong> (e. Muscle Mass), 1.07,9ak*/18.196.589 kr, första kull på tävlingsbanan. </p>



<p class="wp-block-paragraph">Kvällen kompletteras med <strong>Åby</strong> (start 17.45), där ett lopp för hästar av bronsdivisionskaliber visserligen bara lockat sju anmälda, men kvaliteten duger en bit med hästar som <strong>Kipketer Mearas </strong>(e. S.J.’s Caviar),<strong> Dart Kronos</strong> (e. Father Patrick), <strong>Always A Pleasure </strong>(e. Orlando Vici), <strong>Joint Chief</strong> (e. Muscle Hill) och <strong>Garden Leave</strong> (e. Ready Cash). </p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2025/05/250508.pdf" data-type="link" data-id="https://sulkysport.se/wp-content/uploads/2025/05/250508.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>



<p class="has-drop-cap wp-block-paragraph">3 Kommer ni ihåg talangen och vinnaren av Sommarfavoriten 2021, <strong>Chipper Kronos</strong> (e. Southwind Frank)? Valacken tävlade med framgång i Svante Båths regi som två- och treåring. Han debuterade med seger på 1.14,5ak i uttagningslopp till Breeders Course för tvååringar i september och tog fjärdeplatsen i finalen där stallkamraten och en av årets Elitloppshästar <strong>Mellby Jinx</strong> (e. Ready Cash) vann.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2021/02/chipperkronoseam210206adamstromstalltz-617x415.jpg" alt="" class="wp-image-137807"/><figcaption class="wp-element-caption">Chipper Kronos och Erik Adielsson vid en tidigare seger. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p class="wp-block-paragraph">Treåringssäsongen inleddes med segrar i Margaretas Tidiga Unghästserie och Grains lopp, samt under sommaren seger i Sommarfavoriten och finalplatser i båda E3-finalerna (femma och oplacerad). Efter galopp i både Kriteriekval och Breeders Crown-försök försvann hästen från tävlingsbanan. Dessutom lämnade han två år senare Sverige när han såldes för 44.000 kronor på Travera till Danmark sommaren 2023.</p>



<p class="wp-block-paragraph">Danske tränaren Jeppe Rask klickade hem hästen och efter nästan två år var Chipper Kronos tillbaka på banan i måndags. I ett kvallopp i Skive tillsammans med Jeppe Juel travade Rasks sjuåring 1.16,0/2.000 meter och kan därmed återvända till tävlingsbanan på allvar.</p>



<p class="wp-block-paragraph">Chipper Kronos har gjort 13 starter (4-0-1), tagit rekordet 1.12,3am och sprungit in 919.000 kronor.</p>



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



<p class="has-drop-cap wp-block-paragraph">4 Hela tolv banor tävlar i Frankrike idag och premium-tävlingarna hålls i <strong>La Capelle</strong> (första start kl. 11.30). Dit åker Ron Kuiper med Stall Escapades <strong>Hit Money</strong> (e. Cristal Money) för att starta i ett lärlingslopp – Prix d’Abbeville (€24.000) – över 1.800 meter med autostart. Clément Fouquet sitter i sulkyn i loppet där det lockas med 10.800 euro till vinnaren.</p>



<figure class="wp-block-image size-full"><img src="https://sulkysport.se/wp-content/uploads/2017/05/kuiperronportr2.jpg" alt="Ron Kuiper som tog en dubbel med egentränade hästar. Foto Mia Törnberg" class="wp-image-6435"/><figcaption class="wp-element-caption">Ron Kuiper knäpper på sig hjälmen och kör lopp idag. Foto Mia Törnberg</figcaption></figure>



<p class="wp-block-paragraph">Ron Kuiper sätter sig själv upp i sulkyn bakom Stall Escapades <strong>Kathleen du Nord </strong>(e. Un Mec d’Heripre) i Prix de Laon (€24.000) över 2.750 meter. Bland motståndarna finns Jarmo Niskanen-tränade <strong>Katitzi </strong>(e. Earl Simon) med Joan Melis Macias vid tömmarna och där hämtar vinnaren 10.800 euro.</p>



<p class="wp-block-paragraph">I ett sadellopp – Prix de la Pierre d’Haudroy (€21.000) – plockar Jarmo Niskanen också ut <strong>King Size </strong>(e. Earl Simon) och Alexandre Bodin rider den femårige valacken. Distansen är 2.750 meter och förstapriset uppgick till 9.450 euro.</p>



<p class="wp-block-paragraph">Senare under dagen startar även Jarmo Niskanen <strong>Kito Turgot </strong>(e. Rolling d’Heripre) i Prix de Compiegne (€24.000) och även här nyttjar Niskanen Alexandre Bodins tjänster.</p>



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



<p class="has-drop-cap wp-block-paragraph">5 Fjolårets vinnare av Svenskt Trav S:t Leger – <strong>Connors Broline</strong> (e. Twister Bi-Give Your Word), 1.12,2am*/704.646 kr, finns sedan en tid tillbaka i träning hos Christophe Martens i Frankrike sedan hästen sålts till BVBA Lieven de Groote från Svend Dyhrbergs stall.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/11/skarmavbild20241113kl.22.15.58-617x347.jpg" alt="" class="wp-image-659239"/><figcaption class="wp-element-caption">Connors Broline och Stefan Persson efter segern i S:t Leger på Åby.</figcaption></figure>



<p class="wp-block-paragraph">Någon start har det inte blivit för den nye tränaren, men däremot är femåringen preliminäranmäld till ett lopp – Prix Constellation (€60.000) – på Vincennes den 23 maj.</p>



<p class="wp-block-paragraph">Connors Broline har inte startat sedan den 31 december ifjol och då slutade han två i Sylvesterloppet på Axevalla bakom <strong>King Okay</strong>.</p>



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



<p class="has-drop-cap wp-block-paragraph">6 Fjolårets vinnare av Svensk Uppfödningslöpning – <strong>Pele Boko</strong> (e. Readly Express) – vann sin årsdebut på Victoria Park på Wolvega den 25 april. På lördag är Erwin Bots stjärna tillbaka igen och startar i TCT Criterium der Driejarige (€15.400) för hingstar och valacker.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/11/peleboko-617x411.jpg" alt="" class="wp-image-662755"/><figcaption class="wp-element-caption">Pele Boko vinner Uppfödningslöpningen för Örjan Kihlström. Foto: Christer Strand</figcaption></figure>



<p class="wp-block-paragraph">Erwin Bot sitter bakom Pele Boko i ett lopp över 2.100 meter autostart och där det står 7.000 euro på segerchecken.</p>



<p class="wp-block-paragraph"><strong>TCT Criterium der Driejarige</strong> (€15.400)<br>Treåriga hingstar/valacker.<br><em>2.100 meter, autostart.</em></p>



<p class="wp-block-paragraph"><strong>Namn (far) – Tränare</strong></p>



<ol class="wp-block-list">
<li><strong>Malo Renka TF</strong> (e. Alto de Viette) – John Dekker</li>



<li><strong>Mink Boko TF</strong> (e. Helgafell) – Robin Bakker</li>



<li><strong>Pleasure Trans R</strong> (e. Brillantissime) – Micha Brouwer</li>



<li><strong>Pavarotti’s Wish </strong>(e. Offshore Dream) – Bas Crebas</li>



<li><strong>Pele Boko</strong> (e. Readly Express) – Erwin Bot</li>



<li><strong>Moni Making Pace </strong>(e. International Moni) – Dion Tesselaar</li>



<li><strong>Mad Max </strong>(e. Booster Winner) – Jim Veldman</li>



<li><strong>Moon Walker</strong> (e. Maharajah) – Thomas Panschow</li>
</ol>



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



<p class="has-drop-cap wp-block-paragraph">7 Hos Lotta Chaudet på Ecurie du Clair de Lune i Normandie har<strong> Nugget’s Face</strong> (e. Classic Photo-Muscles McNuggets), 1.13,0ak/758.279 kr, blivit mor till en hingst efter Bird Parker. Äger gör Thyself Stable och modern är bokad till Brillantissime i år.</p>



<figure class="wp-block-image alignright size-sulky-liten2"><img src="https://sulkysport.se/wp-content/uploads/2025/05/messengercreation4a163c10f4dc4ff6b0a3a0c84845de3b-350x467.jpeg" alt="" class="wp-image-716502"/><figcaption class="wp-element-caption">Nugget’s Faces son efter Bird Parker. Foto: privat</figcaption></figure>



<p class="wp-block-paragraph">Det är stoets sjunde avkomma och bäst ifrån sig har <strong>Bazinga Cheri</strong> (e. Joke Face), 1.13,8ak*/294.200 kr, gjort. </p>



<p class="wp-block-paragraph">Nugget’s Faces mormor <strong>Pine Nugget</strong> (e. Pine Chip), 1.14,6/$4.187, är halvsyster med <strong>Nan’s Catch</strong> (e. Bonefish), 1.11.3/$766.074, vars mest kända avkomma är <strong>Moni Maker</strong> (e. Speedy Crown), 1.09,7/$5.589.256.</p>



<p class="wp-block-paragraph">Nugget’s Face slutade tvåa i Svensk Uppfödningslöpning, vann Breeders Crown samma år och som treåring tog hon hem ett BC-försök.</p>



<p class="wp-block-paragraph">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>

Fokustema
Sju nyheter vid sju
Läs senare
Unghäststjärnor i duell
Genrepar inför bronsdivisionsfinal. S:t Leger-vinnare i årsdebut på Vincennes? Unghäststjärna på väg tillbaka. Tredje raka för Pele Boko?
Det är några av Sulkysports nyheter i morgonsvepet.
Det är några av Sulkysports nyheter i morgonsvepet.
