
<p class="has-drop-cap wp-block-paragraph">1Tre tunga namn som var vinnare redan i spårlottningen. Eftermiddagens Guldsprintern – upphöjd till 300.000 kronor till vinnaren – är det hetaste loppet när Halmstad (första start 14.45) avrundar banans Sprintermästarweekend med V75-tävlingar.</p>



<p class="wp-block-paragraph">Längsta meritlistan har förstås <strong>Joviality</strong> (e. Chapter Seven), umnghäststjärna i USA som två- och treåring, Derbyvinnare i Sverigee som fyraåring och Prix d’Amérique-trea i år som femåring.<br>Bästa formen aktuell vecka förra året kan <strong>Hustle Rain</strong> (Raja Mirchi) stoltsera med som Sprintermästare 2023.<br>Derbyvinnare på visitkortet har också <strong>Get A Wish</strong> (e. Wishing Stone), som plockade hem den danska upplagan för två år sedan. Nu gör han andra starten för Johan Untersteiner efter en formvässande debut i ny regi för drygt tre veckor sedan.<br>– Han avslutade jättefint i debuten för mig. Jag har sällan åkt ett upplopp så fort, garanti topp fem snabbaste avslutningarna jag åkt över ett upplopp och jag var otroligt nöjd hur han var, sade Untersteiner till V65 Direkt.</p>



<p class="wp-block-paragraph">Halmstadtränaren har elva hästar till start i V75-omgången och en av dem får förtroendet som enkelstreck av Sulkysports expert. Dock inte den som Johan tror allra mest på – så här sade han nämligen om <strong>Eminent Kronos</strong> (V75-1) i V65 Direkt igår:<br>– Barfota borde göra en sekund till och då får de vara väldigt bra för att slå honom. Jag blir otroligt besviken om han inte levererar en bra prestation, sade Johan.</p>



<p class="wp-block-paragraph">Singelstrecket är istället Untersteiner-tränade Hardcore D.K. i lärlingsloppet (V75-4):<br><em>”Hardcore D.K. och Oskar Florhed blir vårt val bland lärlingarna i Wången Cup-finalen. Den av Johan Untersteiner tränade femåringen kommer med full form och detsamma gäller kusken som inte brukar vara rädd att köra offensivt. Är Florhed bara tillräckligt bestämd tror vi det räcker ända fram till ledningen och då ska segerchansen vara god,” </em>skriver Sulkysports expert.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/spelstugan/v75-tips-halmstad-6-juli-2/" target="_blank" rel="noreferrer noopener">––> Här är Sulkysports stora tipsgenomgång till V75 med analyser, spetsbud, spikar, drag och ranking av alla hästar.</a></p>



<p class="wp-block-paragraph">Vill du spela V75 tillsammans med Sulkysport finns följande alternativ:</p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/andelskungen/spel/206687_V75_2024-07-06_18_5">Sulkysport Lilla V75 – 15 andelar á 75 kr/styck</a></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/andelskungen/spel/206688_V75_2024-07-06_18_5">Sulkysport V75 UNIK exklusiv – 15 andelar á 150 kr/styck</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/2019/07/hoting047-617x333.jpg" alt="trav, travsport, sulkysport, hoting" class="wp-image-47441"/><figcaption class="wp-element-caption">Hotingtravet. Foto Jeannie Karlsson/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">2Igår sattes punkt för travsäsongen i Lycksele – idag öppnar nästa sommarpärla för sitt veckolånga meeting. Hotingtravet är en klassiker i trav-Sverige och förutom idag blir det tävlingar med stor häst på tisdag kväll och avslutning med lunchtävlingar på fredag.</p>



<p class="wp-block-paragraph">Hoting (första start 13.15) bjuder på nio lopp under årspremiören och en som trivs extra bra i Hoting är Magnus O Jonsson. Bergsåkertränaren har hela 14 hästar till start, varav fyra vardera i två av loppen. Förra året gjorde Magnus hästar 34 starter under Hotings tredagarsmeeting.<br>– Man blir jätteglad när man ser att intresset för våra små banor ännu är så stort att vi kan arrangera tävlingar med små och ideella medel och trots att vi tappar ett antal starter när Lycksele och Hoting kör dagarna efter varandra…, skriver Hotings Sven-Olof Lindman i programmet inför dagens tävlingar.</p>



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



<p class="has-drop-cap wp-block-paragraph">3Hela 45 (av totalt 65 anmälda) svensktränade hästar tar färjan från fastlandet till Åland och Mariehamn för kvällens tävlingar (första start 19.30) och det finns en del spännande namn i den stora blågula gruppen.</p>



<p class="wp-block-paragraph">Framför allt lastar Claes Sjöström sex hästar på bussen österut, där det största namnet <strong>Jaguar Dream</strong> (e. Love You). Nioåringen kom tillbaka 2021 efter över 1,5 års tävlingsuppehåll och hade två fina säsonger, innan det ifjol blev blott fem starter (två segrar) och avslut redan i juli.<br>Nästan prick ett år senare är hingsten tillbaka på banan ännu en gång och Viktor Malmrot sitter i sulkyn när tränare Sjöström kör en annan dubbelmiljonär, stoet <strong>Breeze</strong> (e. Broad Bahn), i ett femhästarsfält.</p>



<p class="wp-block-paragraph">Kvällens tävlingar är de tredje för säsongen och Örebroamatören Jonas Gylling har gjort två framgångsrika gästspel med två dubblar och Gylling leder körsvensligan på fyra segrar. Han tvingas dock stå från sidan ikväll på grund av avstängning, men fem av stallets hästar finns på plats för att tävla, däribland <strong>Digital Scream</strong> (e. Super Photo Kosmos) och <strong>Victorymoon Gyll</strong> (e. Victor Gio) som båda vann förra tävlingsdagen i Mariehamn.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2024/07/240706.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till lördagens 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/2023/08/castorthestarmed-617x333.jpg" alt="" class="wp-image-478932"/><figcaption class="wp-element-caption">Castor the Star vid segern i bronsdivisionens final under Elitloppshelgen förra året. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">4På måndag blir startlistan klar till den finska fartfesten S:t Michel Ajo (€140.000) i Mikkeli nästa söndag. Ytterligare en svensk häst tar plats i loppet, samtidigt som Daniel Wäjersten byter bidrag i sprinterloppet. </p>



<p class="wp-block-paragraph">Jörgen Westholms sexåring <strong>Castor the Star</strong> (e. Maharajah) är klar för loppet och gör sin åttonde start över sprinterdistans. Mats E Djuse kör som vanligt, precis som i genrepet i Lindesberg i onsdags där Castor the Star från sämsta utgångsläget bakom bilen kördes defensivt och dessutom tävlade med skor när han blev fyra i loppet som vanns av <strong>Francesco Zet</strong> (e. Father Patrick). I starten före slutade Castor the Star tvåa bakom samme Francesco Zet i Norrbottens Stora Pris.</p>



<p class="wp-block-paragraph">Daniel Wäjerstens toppsto <strong>Great Skills</strong> (e. Ready Cash) var tidigt inbjuden till Mikkeli, men tränaren har gjort en rockad och hans bidrag blir istället en annan Ready Cash-son: Mellby Jinx. Denne gjorde stort avtryck i fjolårets upplaga där han öppnade 1.07,5 första kilometern i ledningen. Mellby Jinx höll till fjärdeplatsen när <strong>Hierro Boko</strong> (e. From Above) blev tidernas snabbaste svenskfödde travare på europeisk mark vid segern på 1.08,3/1.609 meter.</p>



<p class="wp-block-paragraph">Förutom segerchecken på 80.000 euro ligger en biljett till Hugo Åbergs Memorial i potten.</p>



<p class="wp-block-paragraph"><strong>Inbjudna till S:t Michel Ajo 2024:</strong></p>



<ul class="wp-block-list">
<li><strong>Castor the Star</strong> (e. Maharajah) – Jörgen Westholm</li>



<li><strong>Denver Gio</strong> (e. Southwind Frank) – Alessandro Gocciadoro</li>



<li><strong>Don Fanucci Zet</strong> (e. Hard Livin) – Daniel Redén</li>



<li><strong>Hierro Boko</strong> (e. From Above) – Risto Kuusisto</li>



<li><strong>Jason’s Camden</strong> (e. Muscle Mass) – Christa Packalén</li>



<li><strong>Mellby Jinx</strong> (e. Ready Cash) – Daniel Wäjersten</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/2023/12/garthvaderjwm231202adamstromstalltz-617x380.jpg" alt="" class="wp-image-529881"/><figcaption class="wp-element-caption">Garth Wader och Jörgen Westholm. Foto Adam Ström/Stalltz.se</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">5En svensktränad travare startar på Enghien (kl. 13.23) idag och Jörgen Westholms <strong>Garth Vader</strong> (e. Ken Warkentin) går ut i Prix du Moulin Rouge (€56.000) över 2.875 meter med Matthieu Abrivard i sulkyn. </p>



<p class="wp-block-paragraph">Störst intresse drar treåringsloppet och Grupp III-klassade Prix de Rome (€80.000) till sig, men loppet är helt utan svenskintresse. Där jagar Sébastien Guaratos italienare <strong>Frank Gio</strong> (e. Face Time Bourbon) fjärde raka segern efter ha vunnit Prix Penthesilea (€70.000), Prix Coronis (€62.000) och Prix de Gien (€70.000). <br>Frank Gio har sina papper i ordning. Mormor <strong>Ilaria Jet</strong> (e. Pine Chip) är en av fyra italienskfödda ston som tjänat över en miljon euro. I avelsboxen kan hon skryta med avkommor som <strong>Tony Gio</strong> (e. Varenne), 1.10,4/€1.005.566, och <strong>Victor Gio </strong>(e. Ready Cash), 1.10,6/€157.401, medan modern till Frank Gio – Zarina Gio (e. Ruty Grif) – gick lottlös från tävlingsbanan, men tog rekordet 1.17,4ak.</p>



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



<p class="has-drop-cap wp-block-paragraph">6Fjärde upplagan av Speed Cup (€50.000)) hålls i Vichy (kl. 18.53) ikväll och det är det enda försök- och finallopp som avgörs på fransk mark. De sex främsta från varje försök går vidare till finalen. <br>Bland deltagarna finns Stall Escapade och Ron Kuiper-tränade <strong>General du Nord</strong> (e. Un Mec d’Heripre) och Théo Briand. </p>



<p class="wp-block-paragraph">Förra året vann Jean-Michel Bazire och <strong>Gaz d’Occagnes </strong>(e. Titan d’Occagnes-Nemenine) både försök och final och han travade 1.10,8a vid finalvinsten.</p>



<p class="wp-block-paragraph"><strong>Speed Cup (€25.00) 7-11 år</strong><br><em>1.609 meter autostart. </em><br><strong>Försök I: </strong></p>



<ol class="wp-block-list">
<li>Histoire Phils </li>



<li>Elixir de Crennes</li>



<li>Falco Fun</li>



<li>Filae de Soyora</li>



<li>Extra du Chatelet</li>



<li>Grigri de Bonheur</li>



<li>Hinden</li>



<li>General du Nord</li>
</ol>



<p class="wp-block-paragraph"><strong>Försök II: </strong></p>



<ol class="wp-block-list">
<li>Flash Money</li>



<li>Hyper Fast</li>



<li>Helios Si</li>



<li>Guerrier Castelets</li>



<li>Domino de la Brise</li>



<li>Gys</li>



<li>Hello Panamine</li>



<li>Falcon d’Ourville</li>
</ol>



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



<p class="has-drop-cap wp-block-paragraph">7Starthästar dominerar kvällens utbud hos auktionsaktören Travera. 27 hästar bjuds ut till försäljning och 22 av dem tillhör kategorin starthästar. Bland dessa finns fyraårige <strong>Furst Igor</strong> (e. Readly Express), som vunnit fyra av tolv starter hittills.</p>



<p class="wp-block-paragraph">Ett dräktigt fölsto med ett hingstföl vid sidan säljs i paket. Det handlar om Cantab Hall-dottern <strong>Renda L.B.</strong> som är dräktig med <strong>Face Time Bourbon</strong> och i år har fått en hingst med <strong>Bar Hopping</strong> som far.</p>



<p class="wp-block-paragraph">En ettåring efter Maharajah och Aroma Grim (1,4 miljoner) säljs, liksom tvååringarna <strong>Nawati</strong> (e. Googoo Gaagaa-Otrobanda, 3,0 miljoner) och <strong>Carte Noir</strong> (e. Fabulous Wood).</p>



<p class="wp-block-paragraph"><a href="https://www.travera.nu/kopa-hast/" target="_blank" rel="noreferrer noopener">Här går det att se hästarna som bjuds ut och följa budgivningen under kvällen.</a></p>

Fokustema
Morgonsvepet
Läs senare
Trehästarsslaget i Halmstad
Banrekordet i fara i guldsprintern? Wäjersten byter häst. Hoting bjuder in till sommarmeeting. Sjöströms topphäst tillbaka efter ett år. Enda försök-finalloppet i Frankrike.
Detta och mer i lördagens ”Sju nyheter vid sju”.
Detta och mer i lördagens ”Sju nyheter vid sju”.
