
<p class="has-drop-cap wp-block-paragraph">1Hon har bara hunnit göra två starter på svensk mark, men redan tjusat den svenska publiken och fört tankarna till de riktigt stora loppen. Fyraåriga stoet <strong>Allegiant</strong> (e. Tactical Landing) köptes till Sverige av Eagles Rising AB, Bjärred (Tobias Persson) i höstas efter avslutad treåringssäsong – för 925.000 dollar (!) på North American Standardbred Mixed Sale i Ohio.<br>Allegiant hade haft en fantastisk treåringssäsong, vilken inbringade 748.027 dollar och sex vinster på 17 starter. Där ingick bland annat finalseger i Breeders Crown ($600.000).<br>I Daniel Redéns regi inledde hon med seger i Rune Johanssons Grand Prix i Örebro i maj på 1.12,4a/2.100 meter – efter 1.09,8 första 1.500 meterna! – och följde upp med lekande lätt spurtvinst i Fyraåringseliten för ston på Solvalla på 1.09,4a/1.640 meter.</p>



<p class="wp-block-paragraph">Ikväll är den tolvfaldiga miljonärskan tillbaka på nya hemmabanan, när <strong>Solvalla</strong> (första start 18.30) bjuder på en högklassig sommarkväll. Toppnumret är fyraåringsloppen Prix Diana Zet och nyinstiftade Prix Tetrick Wania över medeldistans med 400.000 kronor till vinnaren.</p>



<p class="wp-block-paragraph">Prix Diana Zet för ston är Allegiants uppgift och loppet hyllar Stall Zets stostjärna, som i år fått sitt första föl, en hingst med Francesco Zet som far. På tävlingsbanan vann Diana Zet 14 av 24 starter och sprang in 9.637.500 kronor, där segrarna i Svenskt Trav-Oaks, Drottning Silvias Pokal, Stochampionatet och Derbystoet var hennes största.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/11/9s.g.empress-617x333.jpg" alt="" class="wp-image-655217"/><figcaption class="wp-element-caption">S.G.Empress vinner BC-semi för Örjan Kihlström. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph">Allegiant kommer dock inte till dukat bord ikväll med <strong>S.G.Empress</strong> (e. Readly Express) som tuffaste motståndare på papperet.</p>



<p class="wp-block-paragraph">Prix Readly Express för hingstar och valacker flyttade efter sex upplagor till Tingsryd i år och premiärvinnare på nya banan blev <strong>Izod Zet</strong> (e. Propulsion). Därmed skrivs ett nytt loppnamn in i svenska kalendern i år när unghäststjärnan Tetrick Wania namnger fyraåringsloppet.</p>



<p class="wp-block-paragraph"><strong>Tetrick Wania</strong> (e. Muscle Hill) sopade rent som tvååring med triumfer i Svensk Uppfödningslöpning och Svampen, innan han efter en problemfylld treåringssäsong var tillbaka och slutade tvåa i Kungapokalen som fyraåring.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/06/dreamminejwm240629adamstromstalltz-617x409.jpg" alt="" class="wp-image-602954"/><figcaption class="wp-element-caption">Jörgen Westholm jublar när Dream Mine vinner E3-finalen för hingstar/valacker. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p class="wp-block-paragraph">Höga toppar som treåringar hade däremot både <strong>Dream Mine</strong> (e. Maharajah) och <strong>Far Wise As</strong> (e. Face Time Bourbon) på svensk mark. Duon vann nämligen varsin E3-final förra sommaren i regi Jörgen Westholm respektive Jerry Riordan.</p>



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



<p class="has-drop-cap wp-block-paragraph">2Det bjuds fler fyrbenta stjärnor på Solvalla ikväll när en av kullens allra bästa fyraåringar förra året gör årsdebut. Daniel Redéns femåring <strong>Epic Kronos</strong> (e. Muscle Hill) hade ett toppår ifjol med triumfen i Europaderbyt på Vincennes som främsta merit. Dessförinnan hade han slutat tvåa bakom <strong>Fame and Glory</strong> (e. Tactical Landing i Svenskt Travderby.</p>



<p class="wp-block-paragraph">Efter sju månaders tävlingsuppehåll kommer han ut i Icelands lopp för femåringar med 125.000 kronor till vinnaren.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/07/epickronos-617x333.jpg" alt="" class="wp-image-604299"/><figcaption class="wp-element-caption">Epic Kronos och Örjan Kihlström. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph">– Han gick ett banjobb nyligen i Eskilstuna, jag körde lite drygt 1.13 i 2.000 meter med honom och han var fin. Det känns bra, han ska starta igång och som det ser ut ska han gå med skor runt om. Han ska ha ett lopp i kroppen och vi siktar på Margaretas Pokal i augusti med honom. Han var ju lite seg ifjol då vi skulle starta igång honom, men nu är han ett år äldre och så fick han ju ett rejälare jobb. Som han kändes då är han nog redo för en bra prestation. Han har tränat på under hela vintern och våren, jag har inte velat starta honom tidigare för det var ungefär samma tid han årsdebuterade i fjol, säger Daniel Redén till Stall Zets hemsida.</p>



<p class="wp-block-paragraph">I dessa sommartider är det V86-spel från en bana som gäller.</p>



<p class="wp-block-paragraph"><strong>––> Sulkysports spelstuga med viktiga punkter, spikar, drag och favoriter i fara publiceras som vanligt klockan 12.00 idag.</strong></p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2025/06/18v86.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till kvällens tävlingar.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">3 Tio finalplatser står på spel i Stosprintern på Halmstadtravet på måndag. De fyra främsta ettorna och tvåorna plus de två högst rankade treorna är klara för finalen torsdagen den 3 juli på Halmstadtravet. Där väntar ett förstapris på 900.000 kronor.</p>



<p class="wp-block-paragraph">33 hästar har anmälts och de är fördelade på 22 olika tränare och flest anmälda hästar har Mattias Djuse med fyra ston; <strong>Global Fragance</strong>, <strong>Legacy of Sound</strong>, <strong>Mellby Minerva</strong> och <strong>Olivia Bros</strong>.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/11/mattiasdjuse-617x333.jpg" alt="" class="wp-image-656381"/><figcaption class="wp-element-caption">Mattias Djuse har fyra hästar anmälda till Stosprintern. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph">Vinstrikast av stona är Daniel Wäjerstens <strong>Vivillion </strong>(e. Propulsion) med 4.333.500 kronor på bankboken. Sjusiffrigt har också <strong>Oriana Boko</strong> (2.662.194 kr), <strong>Olivia Bros </strong>(2.234.500 kr), <strong>Volcanic Blue Chip</strong> (2.016.708 kr), <strong>Kilimanjaro Face</strong> (1.141.381 kr) och <strong>Beedrill </strong>(1.137.000 kr) sprungit in.</p>



<p class="wp-block-paragraph">Saknas i startlistan gör de två vinstrikaste svenskfödda fyraåriga stona i år. André Eklunds Drottning Silvias Pokal-vinnare <strong>Panthere d’Inverne</strong> och Roger Walmanns <strong>S.G. Empress</strong>, vilka sprungit in 1.199.000 respektive 951.500 kronor i år.</p>



<h2 class="wp-block-heading">Tränare med flest anmälda ston till Stosprintern</h2>



<p class="wp-block-paragraph"><strong>Tränare – Anmälda ston</strong></p>



<ul class="wp-block-list">
<li><strong>Mattias Djuse</strong> – 4</li>



<li><strong>Fredrik Wallin</strong> – 3</li>



<li><strong>André Eklundh </strong>– 2</li>



<li><strong>Joakim Elfving </strong>– 2</li>



<li><strong>Adrian Kolgjini </strong>– 2</li>



<li><strong>Conrad Lugauer</strong> – 2</li>



<li><strong>Daniel Redén</strong> – 2</li>



<li><strong>Daniel Wäjersten</strong> – 2</li>
</ul>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2025/06/609969.pdf" data-type="link" data-id="https://sulkysport.se/wp-content/uploads/2025/06/609969.pdf" target="_blank" rel="noreferrer noopener">Startlistorna till Halmstads tävlingar på måndag hittar ni här.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">4Johan Untersteiners <strong>Mateo di Quattro</strong> (e. Bird Parker) trivs som fisken i vattnet på fransk mark och senare idag jagar hästen sin fjärde raka seger i Prix de l’Hippodrome d’Agen (€35.000) i <a href="https://sulkysport.se/trav-och-galopp/toulouse-2025-06-18/" data-type="link" data-id="https://sulkysport.se/trav-och-galopp/toulouse-2025-06-18/" target="_blank" rel="noreferrer noopener">Toulouse</a>.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/02/luneville2-617x275.jpg" alt="" class="wp-image-691696"/><figcaption class="wp-element-caption">Mateo di Quattro och Benjamin Rochard håller ifrån sig Je Te Cherche i spurten på Vincennes. Foto: Gerard Forni</figcaption></figure>



<p class="wp-block-paragraph">Frédéric Clozier sitter i sulkyn i ett autostartlopp över 2.750 meter och där ytterligare en svenskfödd travare – <strong>Junkie</strong> (e. Varenne) – syns i startlistan. Första start är klockan 17.40.</p>



<p class="wp-block-paragraph">I Toulouse avgörs också den sjunde etappen i Grand National du Trot (€90.000) och där <strong>Jango Vici</strong> (e. Dragon des Racques) har en intressant uppgift på papperet. Han kommer närmast från seger i ett försök i GNT-serien i Le Croisé-Laroche.</p>



<p class="wp-block-paragraph">Två svenskfödda travare syns också i Grand National des Jockeys (€35.000) och i sadelloppet för lärlingar startar <strong>Dowhatyoudodowell </strong>(e. Maharajah) och <strong>Huis Clos </strong>(e. Bird Parker) från 25 meters tillägg och där grunddistansen är 2.950 meter.</p>



<p class="wp-block-paragraph">Fyra svenskfödda travare syns i <strong>Chartres </strong>(första start kl. 11.40) i sadelloppet Prix Hommage A Christelle Zimmer (€26.000) över 2.800 meter med 11.700 euro till vinnaren.</p>



<p class="wp-block-paragraph">Startar gör Jimmy Dahlmans <strong>Global Attention</strong> (e. Love You), Markus B Svedbergs <strong>Battuta Face</strong> (e. Mosaique Face), Conrad Lugauers <strong>Steady Victory </strong>(e. S.J.’s Caviar) och Erik Bondo-tränade <strong>Hashtag Simoni</strong> (e. Orlando Vici).</p>



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



<p class="has-drop-cap wp-block-paragraph">5 Sjuårige valacken <strong>Fashion Frenzie</strong> (e. Archangel-Striking Fashion) blev den fjärde hästen som tangerade det kanadensiska rekordet när han travade 1.08,6/1.609 meter på Mohawk Raceway i måndags för Louis-Philippe Roy och i sin debut för Eric Nadeau.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/06/fashionfrenzie061625newimagemedia1024-617x347.jpg" alt="" class="wp-image-732272"/><figcaption class="wp-element-caption">Fashion Frenzie tangerade det kanadensiska rekordet igår och det var inte första gången det skedde&#8230; Foto: New Image Media</figcaption></figure>



<p class="wp-block-paragraph">Det ursprungliga rekordet på kanadensisk mark sattes 2019 av <strong>Atlanta</strong> och har senare tangerats av <strong>Alrajah One</strong> (2023), <strong>Gaines Hanover</strong> (2024) och <strong>Emoticon Legacy</strong> (2025).</p>



<p class="wp-block-paragraph">Fashion Frenzie – med 1.371.347 dollar på bankboken – är ny i träning hos Eric Nadeau sedan hans tidigare tränare <a href="https://sulkysport.se/jeffrey-gillis-avstangd-i-tio-ar/" target="_blank" rel="noreferrer noopener">Jeff Gillis </a>nyligen dömdes till tio års avstängning och 40.000 dollar i böter för flera dopingöverträdelser.</p>



<p class="wp-block-paragraph">Fashion Frenzie var rena fyndet när han såldes som ettåring för 7.000 kanadensiska dollar på London Selected Yearling Sale. Han är undan <strong>Striking Fashion</strong> (e. Striking Sahbra), 1.12,7/C$70.775, som också lämnat <strong>Holiday Holly</strong> (e. Holiday Road), 1.12,0/C$128.394.</p>



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



<p class="has-drop-cap wp-block-paragraph">6 En av Australiens framgångsrikaste travare gjorde sin sista start i lördags. Nioåriga stoet<strong> Im Ready Jet</strong> (e. Quaker Jet-Im Ready Set), 1.10,2*/$811.750 dollar, lägger tävlingsskorna på hyllan efter 29 segrar, 14 andra- och lika många tredjeplatser på 84 starter.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/06/imreadyjet20211119-617x573.jpg" alt="" class="wp-image-732258"/><figcaption class="wp-element-caption">Im Ready Jet. Foto: Stuart McCormick</figcaption></figure>



<p class="wp-block-paragraph">– Efter två mindre bra prestationer bestämde vi oss för att pensionera henne. Hon är en för bra häst för att förringas efter allt hon har uppnått, sade tränaren Andy Gath till The Trots.</p>



<p class="wp-block-paragraph">Totalt räknade Im Ready Jet in åtta Grupp I-segrar under Anton Golinos och senare Andy Gaths beskydd. Tre av Grupp I-segrarna kom i Breeders Crown som två-, tre- och fyraåring.</p>



<p class="wp-block-paragraph">Im Ready Jet är undan <strong>Im Ready Set </strong>(e. Monarchy), 1.12,5<em>/</em>$69.031, vilken också lämnat <strong>Imsettogo</strong> (e. Used To Me), 1.14,2/$119.135.</p>



<p class="wp-block-paragraph">Vem hennes första partner blir i avelsboxen är ännu inte bestämt.</p>



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



<p class="has-drop-cap wp-block-paragraph">7 <strong>Miracle de Ladil </strong>(e. Gotland-Rosy Pierre) tog hem treåringsloppet <a href="https://federaciobaleardetrot.com/verCarrera.php?idCarrera=148889&#038;pagina=1" data-type="link" data-id="https://federaciobaleardetrot.com/verCarrera.php?idCarrera=148889&#038;pagina=1">Gran Premio Manacor</a> (€18.000) på hipodrom Manacor i söndags. Jamie Fluxa Gomila satt i segersulkyn när hingsten besegrade Matador (e. Tobin Kronos) och båda hästarna kom hem på 1.17,9a/2.375 meter.</p>



<figure class="wp-block-image size-full"><img src="https://sulkysport.se/wp-content/uploads/2025/06/skarmavbild20250617kl.12.53.05.jpg" alt="" class="wp-image-732252"/><figcaption class="wp-element-caption">Vinnaren Miracle de Ladil stormar fram i tredjespår och plockar senare ner invändige Matador.</figcaption></figure>



<p class="wp-block-paragraph">Miracle de Ladil satt sist i fältet, attackerade i tredjespår på sista långsidan och fångade in ledande Matador kort före linjen. Vinsten var värd 8.280 euro.</p>



<p class="wp-block-paragraph">Fem segrar på tolv starter och 14.276 intjänade euro har det blivit för Miracle de Ladil, vars mor är svenskregistrerade <strong>Rosy Pierre</strong> (e. Love You), 1.15,7m/180.597 kr, och som vann sex lopp på 18 starter.</p>



<p class="wp-block-paragraph">Vinstrikast är duon <strong>Kocy Occagnes</strong> (e. Bird Parker), 1.11,8ak<em>/</em>469.572 kr, och <strong>Mega Occagnes </strong>(e. Propulsion), 1.12,9ak/394.268 kr. Rosy Pierre är i sin tur halvsyster med holländske <strong>Amour d’Occagnes</strong> (e. Diamant Gede), 1.10,8ak*/6.269.411 kr.</p>

Fokustema
Sju nyheter vid sju
Läs senare
Allegiant flyger igen
Topptrav med fyraåringsstjärnor på Solvalla. Redén om Europaderbyvinnarens årsdebut. Han har flest hästar till start i Stosprintern. Fjärde raka för Mateo di Quattro? Åttafaldig Grupp I-vinnare till avel. Gotland-son vann storlopp.
Det är några av Sulkysports nyheter i morgonsvepet.
Det är några av Sulkysports nyheter i morgonsvepet.
