
<p class="has-drop-cap wp-block-paragraph">1Ett anrikt treåringslopp för ston på Axevalla är söndagens höjdpunkt. Guldstoet avgjordes för första gången 1972 och i eftermiddag på Stochampionatsbanan är det dags för årets upplaga med 350.000 kronor till vinnaren.</p>



<p class="wp-block-paragraph">Att vinna Axevallas två största lopp för ston, Guldstoet och Stochampionatet, har bara fyra damer lyckats med i historien. Och det är ingen dålig kvartett! Eller vad sägs om Ina<strong> Scot, Lovely Godiva, Lie Detector</strong> och <strong>Viola Silas</strong>!<br>När Ina Scot och Lovely Godiva segrade i Guldstoet i början av 1990-talet avgjordes loppet i december, men sedan 2001 har loppet hittat sin plats första veckan i juni.</p>



<p class="wp-block-paragraph">Förra året blev det seger för firma Örjan Kihlström/Roger Walmann genom <strong>Loke Sancy Diamond</strong> (e. Raja Mirchi) och visst kan det bli repris i år. Duon mönstrar <strong>S.G.Empress</strong> (e. Readly Express), som efter tre starter fortsatt är obesegrad. I senaste framträdandet i en avdelning i Margaretas Tidiga Unghästserie fick hon dock nöja sig med delad seger med <strong>Unforgettable A.Y. </strong>(e. From Above).</p>



<p class="wp-block-paragraph"><strong>Tio senaste vinnarna av Guldstoet på Axevalla:</strong></p>



<ul class="wp-block-list">
<li>2014 <strong>Diamond River</strong> (e. Ready Cash) – Johnny Takter (Ola Samuelsson) – 1.14,9a</li>



<li>2015 <strong>She&#8217;s From Above</strong> (e. From Above) – Claes Sjöström – 1.16,0a</li>



<li>2016 <strong>Dream On Honey</strong> (e. Andover Andover) – Jim Oscarsson – 1.13,6a</li>



<li>2017 <strong>White Lightning</strong> (e. Maharajah) – Jörgen Westholm – 1.15,0a</li>



<li>2018 <strong>A Sweet Dance</strong> (e. Maharajah) – Johnny Takter (Helena Burman) – 1.14,4a</li>



<li>2019 <strong>Zolly</strong> (e. Zola Boko) – Mattias Djuse – 1.14,9a</li>



<li>2020 <strong>Hill’s Angel</strong> (e. Muscle Hill) – Björn Goop – 1.14,1a</li>



<li>2021<strong> Islay Mist Sisu</strong> (e. Beer Summit) – Per Nordström – 1.13,9a</li>



<li>2022 <strong>Xerava C.D.</strong> (e. Uncle Lasse) – Mats E Djuse (Hans R Strömberg) 1.13,8a</li>



<li>2023 <strong>Loke Sancy Diamond</strong> (e. Raja Mirchi) – Örjan Kihlström (Roger Walmann) 1.14,2a</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/2020/09/osterlingsusannehsulky2-617x333.jpg" alt="" class="wp-image-109917"/><figcaption class="wp-element-caption">Susanne H Osterling. Foto Hanold/ALN</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">2Förutom Guldstoet bjuds damloppet Hertiginnan av Västergötland Kronprinsessan Victorias lopp med hela 150.000 kronor till vinnaren. Loppet har körts sedan 1993 på Axevalla och initiativtagare var Ulla Ullberg, som även skänkt det vandringspris som Susanne H Osterling lade beslag på 2016 efter tre segrar.</p>



<p class="wp-block-paragraph">Ett nytt vandringspris plockades fram och där har redan Susanne två inteckningar. Solängettränaren finns förstås med bland de tolv som gör upp om segern i årets upplaga av damloppet och sitter upp bakom Josefine Ivehag-tränade <strong>Wilson Laylock</strong> (e. Love You).<br>Förra året blev det seger för Kajsa Frick bakom <strong>Benita Winner</strong> (e. Muscle Massive) och Kajsa har en intressant uppsittning även i år i norsktränade jänkaren <strong>Wishful Order </strong>(e. Muscle Hill).</p>



<p class="wp-block-paragraph">Totalt har 20 kvinnliga kuskar vunnit Kronprinsessan Victorias lopp och dessa har segrat två gånger eller fler:</p>



<ul class="wp-block-list">
<li><strong>Fem segrar:</strong> Susanne H Osterling</li>



<li><strong>Fyra segrar:</strong> Kajsa Frick</li>



<li>T<strong>re segrar: </strong>Charlotta B Svensson</li>



<li><strong>Två segrar:</strong> Katarina Aurell och Elin Gustavsson</li>
</ul>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2024/05/02gs75.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till dagens tävlingar på Axevalla.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">3 <strong>Vernissage Grif</strong> (e. Varenne) blev av med sitt Europarekord på 1.08,1 från Cagnes-sur-Mer i våras när <strong>Horsy Dream</strong> (e. Scipion du Goutier) travade 1.08,0a/1.609 meter vid sin finaltriumf i Elitloppet på Solvalla.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/05/2ebatterie2-617x518.jpg" alt="" class="wp-image-578589"/><figcaption class="wp-element-caption">Vernissage Grif vid sin försöksvinst i Gran Premio della Lotteria. Foto Gerard Forni.</figcaption></figure>



<p class="wp-block-paragraph">Efter att Vernissage Grif vunnit sitt försök i Gran Premio della Lotteria och galopperat bort sig i finalen har inte Alessandro Gocciadoros euromiljonär synts på tävlingsovalen. Nu har han beslutat sig för att nästa start blir i Prix René Ballière (€200.000) på Vincennes den 23 juni och där kan mycket väl stöta på Horsy Dream, men också <strong>Idao de Tillard</strong>, <strong>Go On Boy</strong> och <strong>Hohneck</strong>.</p>



<p class="wp-block-paragraph">Det betyder att det blir en match mellan Europas två snabbaste travare genom tiderna över 2.100 meter autostart. Snabbaste medeldistanstiden på Vincennes delas mellan tre hästar; <strong>Face Time Bourbon</strong> (2021), <strong>Vivid Wise As</strong> (2022) och <strong>Hokkaido Jiel </strong>(2023) har alla travat 1.09,1 med startbilens hjälp.</p>



<p class="wp-block-paragraph">För Romain Derieux och Go On Boy kan det mycket väl bli Kymi Grand Prix (€160.000) i Kouvola den 15 juni istället för Vincennes, säger han i ett uttalande till Paris-Turf:</p>



<p class="wp-block-paragraph">– Jag har två alternativ. Kymi Grand Prix där han slutade tvåa förra året eller Prix René Ballière. Beroende på motståndet kommer jag att välja det bästa alternativet för vår del. Med tanke på att det finns ett flygplan till Finland, även om det lyfter från Liège. Vi kommer att fatta beslutet i lugn och ro.</p>



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



<p class="has-drop-cap wp-block-paragraph">4 Travera-auktionen var tillbaka igår efter en veckas uppehåll – läs Elitloppshelgen på Solvalla – och allra mest av de utbjudna travarna betalades för <strong>Superior Bro</strong> (e. Maharajah-Etoile Mearas), 1.13,1ak*/336.800 kr, och det var Östersundsproffset Thomas B Nilsson som hade högsta budet på 150.000 kronor. Tre raka segrar står den femårige valacken med, vilken tidigare tränats av Jörgen Westholm.</p>



<p class="wp-block-paragraph">Ytterligare tre hästar såldes för sexsiffrigt belopp: Svante Båth lade beslag på Don Fanucci Zets lillasyster <strong>Cutting Corners</strong> (e. Broadway Hall-Kissed By the West), 1.14,2am*/184.000 kr, för 140.000 kronor medan <strong>Hamiltion Atout</strong> (e. Un Mec d’Heripre-Opaline d’Atout), 1.11,9m/583.183 kr, och <strong>Bingo Pop</strong> (e. S.J.’s Caviar-Love To Lindy), 1.14,2m/176.900 kr, hamnade hos anonyma händer för 100.000 kronor vardera.</p>



<p class="wp-block-paragraph"><a href="https://www.travera.nu/auktionsresultat/" data-type="link" data-id="https://www.travera.nu/auktionsresultat/" target="_blank" rel="noreferrer noopener">Samtliga resultat från auktionen hittar ni här.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">5 Det tävlas flitigt på fransk mark och på de tre ”premium-banorna” finns det bara en svensk representant och det i Reims. I Frankrike verksamma Marie Norberg startar <strong>Justess Viking</strong> (e. Ubriaco), 1.12,6/€49.935, i femåringsloppet Prix du Champagne Joseph Perrier (€24.000) över distansen 2.500 meter med 10.800 euro till vinnaren.</p>



<p class="wp-block-paragraph">Stoet jagar fortsatt sina första seger efter 42 starter. En andraplats och sex tredjepris har det blivit så här långt i karriären.</p>



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



<p class="has-drop-cap wp-block-paragraph">6 Stall Nyx rapporterar om sitt andra föl i år. <strong>La Camilla Pellini </strong>(e. Ready Cash), 1.13,8am/292.750 kr, har blivit mor till en dotter efter Greenshoe och nu går hon till Prix d&#8217;Amérique-vinnaren Idao de Tillard.</p>



<figure class="wp-block-image size-full"><img src="https://sulkysport.se/wp-content/uploads/2024/06/skarmavbild20240601kl.11.45.02.jpg" alt="" class="wp-image-591361"/></figure>



<p class="wp-block-paragraph">Det är hennes andra avkomma och La Camilla Pellini har också ett tvåårigt sto och <strong>Kiss My Feet</strong> (e. Greenshoe) är i träning hos Daniel Wäjersten.</p>



<p class="wp-block-paragraph">La Camilla Pellini startade elva gånger, vann tre lopp och däribland ett försök i Diamantstoet. Mormor <strong>Anna Karin’s Girl </strong>(e. Malabar Man), 1.13,8/$, har sin främsta svenskfödda avkomma i <strong>Fairplay Pellini</strong> (e. Maharajah), 1.12,3al/694.600 kr, medan hon på andra sidan Atlanten lämnat <strong>Trouble</strong> ($224.250), <strong>Brooklyn</strong> ($182.522) och <strong>Michael’s Wild Boy</strong> ($161.261).</p>



<p class="wp-block-paragraph">Mormor är också Anna Karin’s Girl till<strong> Kings County </strong>($535.416), <strong>Swiss House Onfire </strong>($286.339) och <strong>Brooklyn Hill </strong>(2.397.796 kr).</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>



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



<p class="has-drop-cap wp-block-paragraph">7 Duindigt står i centrum i Holland idag när Criterum der Driejarige avgörs för hingstar/valacker (€13.200) respektive ston (€10.450) registrerade i Nederländerna.</p>



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



<p class="wp-block-paragraph"><strong>Namn (far) – Körsven</strong></p>



<ol class="wp-block-list">
<li><strong>Orvill Stone</strong> (e. Wishing Stone) – Robin Bakker</li>



<li><strong>Oliver Transs R </strong>(e. Love You) – Micha Brouwer</li>



<li><strong>Obelix Newport </strong>(e. Muscle Massive) – Erwin Bot</li>



<li><strong>Oliver Kite</strong> (e. Offshore Dream) – Jaap van Rijn</li>



<li><strong>Olympus Dragon</strong> (e. Propulsion) – Dion Tesselaar</li>



<li><strong>Outlaw B Darby</strong> (e. Victor Gio) – Jan Baas</li>



<li><strong>Ojuul Hazelaar </strong>(e. Hans Hazelaar) – Jim Veldman</li>



<li><strong>Luciano Vredebest</strong> (e. Feliciano) – André Bakker</li>



<li><strong>Otini Bianco </strong>(e. Ufo Kievitshof) – Rob de Vlieger</li>



<li><strong>Onyx Vredebest </strong>(e. Muscle Mass) – Patrick de Haan</li>



<li><strong>Offlimit Brigadoon</strong> (e. Captain Sparrow) – Danny Brouwer</li>
</ol>



<p class="wp-block-paragraph"><strong>Criterium der Driejarige</strong> (€10.450)<br>Treåriga ston.<br><em>2.000 meter, autostart.</em></p>



<p class="wp-block-paragraph"><strong>Namn (far) – Körsven</strong></p>



<ol class="wp-block-list">
<li><strong>Oh Marie </strong>(e. Propulsion) – Bas Crebas</li>



<li><strong>Olivia Hazelaar</strong> (e. Hans Hazelaar) – Jim Veldman</li>



<li><strong>Olivia W Boko</strong> (e. Donato Hanover) – Jeffrey Mieras</li>



<li><strong>Only Love </strong>(e. Love You) – Robin Bakker</li>



<li><strong>Oreal Boko</strong> (e. International Moni) – Dion Tesselaar</li>



<li><strong>Opal Stone</strong> (e. Charly du Noyer) – Dennis Minnema</li>



<li><strong>Olize JB Boko</strong> (e. Campo Bahia) – Hanna Huygens</li>
</ol>

Fokustema
Morgonsvepet
Läs senare
I Inas och Lovely Godivas hovspår
Obesegrade talanger i Guldstoet. Tjejer gör upp i kuskmatch. Europas snabbaste hästar genom tiderna möts på Vincennes. Unghästlopp i Holland och nyfött.
Det är några av Sulkysports ”sju nyheter vid sju.”
Det är några av Sulkysports ”sju nyheter vid sju.”
