
<p class="has-drop-cap wp-block-paragraph">1För två år sedan möttes de i Sprintermästarens final, där <strong>Önas Prince</strong> (e. Chocolatier) var den bäste och segrade på 1.09,8a/1.609 meter, medan <strong>Hell Bent For Am</strong> (e. Muscle Hill) var rejält distanserad som fyra på 1.10,9.<br>Sedan dess har runnit mycket vatten under broarna. Önas Prince har etablerat sig i den äldre eliten med 17 starter (7-0-4) som fem- och sexåring och dubbla finalplatser i Elitloppet, medan Hell Bent For Am blott gjort tre starter efter fyraåringssäsongen och i år återkommit efter drygt ett års tävlingsfrånvaro.</p>



<p class="wp-block-paragraph">När Halmstads gulddivisionslopp på Sprintermästarlördagen gått från 2.140 meter till den engelska milen och lockar med 200.000 kronor i förstapris möts de båda igen. Det blir för fjärde gången och Önas Prince har aldrig fått stryk av sin jämngamle konkurrent.<br>Efter att ha slutat oplacerad i Kriteriet 2020 (Hell Bent For Am diskvalificerad för galopp) vann Önas Prince Sprintermästarfinalen och ett Breeders Crown-försök i Mantorp, där Hell Bent For Am båda gångerna fanns i det slagna fältet.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2021/07/onasprince1-1-617x333.jpg" alt="" class="wp-image-186526"/><figcaption class="wp-element-caption">Önas Prince och Per Nordström imponerade vid segern från dödens i Sprintermästaren före Rome Pays Off. Foto Lars B Persson</figcaption></figure>



<p class="wp-block-paragraph">Spårlottningen vann Hell Bent For Am med spår ett – statistiken talar för Önas Prince som är obesegrad efter sex starter i Halmstad!<br>– Vi kollade upp honom efter Elitloppet, han hade känningar i sina framknän och behandlades. Sedan började vi så smått jogga igång, men han har inte fått några rundbanejobb så han ska få en riktig genomkörare inför Åbergs. Han trivs väldigt bra i Halmstad. Han har aldrig haft någon dålig upplevelse där, utan han har enbart positiva känslor när han åker dit och det är ett extra plus i kanten, sade Per Nordström till V65 Direkt. </p>



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



<p class="has-drop-cap wp-block-paragraph">2Det ligger cirka 19,5 miljoner kronor extra i sjurättspotten på V75 i eftermiddagens tävlingar i Halmstad (första start 14.45) och Sulkysports tipsexpert har hittat ett spännande drag som enkelstreck. Så här skriver han om sin vinnare i bronsdivisionsförsöket:<br><em>”Vår andra spik i omgången är mer av det chansartade och ”roliga” slaget. Christoffer Erikssons <strong>Grappa Boy</strong> (V75-3) behöver lite hjälp med farthållningen från bakspår, men löser det sig bara det minsta är vi inne på att femåringen tuggar ner motståndet till slut.”</em></p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/spelstugan/v75-tips-halmstad-8-juli/" target="_blank" rel="noreferrer noopener">Här är hela tipsgenomgången med analyser, spetsstrider, systemförslag och ranking av alla hästar.</a></p>



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



<p class="wp-block-paragraph"><a href="https://www.atg.se/andelskungen/spel/206687_V75_2023-07-08_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_2023-07-08_18_5">Sulkysport V75 – 15 andelar á 150 kr/styck</a></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/andelskungen/spel/206689_V75_2023-07-08_18_5">Sulkysport Stora V75 – 15 andelar á 250 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">3Igår säkrade John Östman årets första banchampionat när Lycksele avslutade sommarens travvecka efter tre tävlingsdagar. Redan idag tar nästa bana vid när Hoting (start 13.15) drar igång sin travvecka, där det även tävlas med stor häst på tisdag och fredag nästa vecka.<br>28 lopp ska avverkas innan Hotingveckan avslutas nästa fredag och vid dagens premiär dyker Lyckselechampion Östman upp och kör fyra hästar. Två av dem tränar av trogne Hotinggästen Magnus O Jonsson, som har hela 13 starthästar ut under premiärdagen.</p>



<p class="wp-block-paragraph">Precis som för övriga sommarbanor är dock prismedlen sänkta även i Hoting, där det är 15.000 kronor i förstapris i alla lopp idag.<br><em>”Förutom att jag personligen och för vår tre småbanor är väldigt besviken på Svensk Travsport angående hantering av sänkta prispengar, ändrade dagtyper och obefintlig kontakter i samband med detta, så känns det ändå bra att vi kan presentera riktigt fina tävlingar i Oviken, Lycksele och Hoting”, </em>skriver Hotingtravets starke man Sven-Olov Lindman i ledaren till dagens tävlingar.</p>



<p class="wp-block-paragraph">Dessutom väntar kvällstrav på Åland i Mariehamn (första start 19.30), där det är många svenskar på plats. 22 svensktränade hästar finns i de sju loppen, där det dessutom är jackpot på V65-spelet med cirka 420.000 kronor extra i sexrättspotten.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2023/07/230708.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till lördagens tävlingar i Sverige och på Åland.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">4I torsdags fick Åke Svanstedts stjärnsto <strong>Jiggy Jog</strong> (e. Walner) en biljett till ”VM-loppet” Yonkers International i höst. I natt på Meadowlands väntar årets första stora uppgift i finalen av Graduate Series ($230.000) på Meadowlands. Dit kommer Jiggy Jog med åtta raka segrar, varav de två senaste i försökt till Graduate Series ($75.000) där hon travat 1.08,8 över den engelsk milen båda gångerna. Dexter Dunn hoppar upp i sulkyn bakom det svenskfödda stoet.</p>



<p class="wp-block-paragraph">I finalen möter hon en duo från Nancy Takters stall, <strong>Keg Stand</strong> (e. Bar Hopping) och <strong>Pretender</strong> (e. Muscle Hill), Anette Lorentzon-tränade <strong>Iwon’t Backdown Ås</strong> (e. Lionhunter), samt fjolårets Hambovinnare <strong>Cool Papa Bell</strong> (e. Chapter Seven).</p>



<p class="wp-block-paragraph"><strong>Startlista Graduate Series ($230.000), 1.609 meter autostart: </strong>1 Jiggy Jog, 2 Looks Like Moni, 3 Iwon’t Backdown Ås, 4 Pretender, 5 Slay, 6 Keg Stand, 7 Pappardelle, 8 Cool Papa Bell.</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/2022/10/coinsglennea220901o-617x333.jpg" alt="" class="wp-image-365178"/><figcaption class="wp-element-caption">Glenn har blivit Coins Glenn. Foto Gunilla König/Stalltz.se</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">5Storhästägaren KB Capulus Horses, Kullavik, med 26 helägda hästar i svensk träning, ska dra ned på hästantalet. Vid kvällens auktion på Travera bjuder hästägarna ut fyra hästar till försäljning. En av dem är treårige <strong>Coins Glenn</strong> (e. Coin Perdu), som inledde tävlingskarriären med tre raka segrar som tvååring.<br>En annan är jämngamle <strong>Kit Kat Mearas</strong> (e. Maharajah), som kvalade på 1.18,7 på Solvalla i onsdags, samma kväll som storasyster <strong>Jelly Bean Mearas</strong> (e. Cantab Hall) vann en avdelning i Margaretas Tidiga Unghästserie.</p>



<p class="wp-block-paragraph">Merparten av kvällens auktionshästar tillhör kategorin starthästar, hela 23 som är tre år och äldre. Här märks också fyraåriga <strong>Miss Mighty</strong> (e. S.J.’s Caviar), som vann diamantostoförsök i vintras.</p>



<p class="wp-block-paragraph">Sju tvååringar med fäderna Brillantissime, Creatine, Googoo Gaagaa, S.J.’s Caviar, Un Mec d’Heripre, Walner och Who’s Who bjuds också ut, liksom fölsto och Oaks-trean Op&#8217;s First Girl.</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 säljs och följa budgivningen under kvällen.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">6Det kryllar av blågula hopp vid eftermiddagens tävlingar på Parisbanan Enghien (första start 13.23). Sex av de 13 deltagarna i Prix O’Orgeval (€56.000) är svenskfödda och fyra av dem därtill svensktränade.<br>Tomas Malmqvist bidrar med <strong>Digital Dominance</strong> (e. Super Photo Kosmos), Jörgen Westholm med <strong>Strong Heartbeat</strong> (e. Maharajah), Emilia Getterman med <strong>Musett af Djupmyra</strong> (e. Super Photo Kosmos) och Ron Kuiper med <strong>Tale of Jacks</strong> (e. Intoxicated).<br>Därtill startar Philippe Daugeard <strong>Staro Mojito</strong> (e. Make it Happen) och Didier Brohier luftar <strong>Mellby Guard</strong> (e. Going Kronos).</p>



<p class="wp-block-paragraph">Tomas Malmqvist har även <strong>Iron Jet</strong> (e. Charly du Noyer) till start i Prix du Moulin Rouge (€46.000) samt <strong>Isla Jet</strong> (e. Bold Eagle) i Grupp III-klassade Prix du Louvre (€80.000).</p>



<p class="wp-block-paragraph">Ytterligare ett Grupp III-lopp avgörs under eftermiddagen genom treåringsloppet Prix de Rome (€80.000) och det är förklaringen till att Alessandro Gocciadoro valt bort tävlingarna i Halmstad. <strong>Elton Wise</strong> (e. Maharajah) är den treåring han sitter bakom i jakten i det nämnda loppet och i ”svenskkampen” Prix O’Orgeval startar han därtill Igor Font-sonen <strong>Amornero Roc</strong>.</p>



<p class="wp-block-paragraph">Christoffer Eriksson har likaså starthäst i Frankrike, men då i Vichy (första start 18.55). Då handlar det om <strong>Self Explosive</strong> (e. Explosive Matter) som under Marie Darbord ska försöka bärga sin sjätte årsseger i Frankrike i evakueringsloppet Prix Gaston Roussel (€37.000).</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/trav-och-galopp/enghien-2023-07-08/" target="_blank" rel="noreferrer noopener">Här kan du ta del av dagens startlistor till tävlingarna på Enghien.</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/2022/08/kilmisterbsm220806adamstromstalltz-617x385.jpg" alt="" class="wp-image-337391"/><figcaption class="wp-element-caption">Kilmister vid segern i Peter Haughton Memorial. Foto Adam Ström/stalltz.se</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">7Årets mest penningstinna treåringslopp hittills 2023 avgörs i USA ikväll. Harry Zweig Memorial ($350.000) på Vernon Downs har lockat två svensktränade travare; Marcus Melanders Peter Haughton Memorial-vinnare <strong>Kilmister</strong> (e. Chapter Seven), 1.10,0/$506.326, och Åke Svanstedts <strong>Cecil Hanover</strong> (e. Chapter Seven), 1.10,0*/$173.455. <br>Kilmister kommer närmast från seger i Empire Breeders Classic ($95.771) på Vernon Downs, medan Cecil Hanover var tvåa i samma löpning och slagen med en dryg längd av Marcus Melanders travare. </p>



<p class="wp-block-paragraph">I stonas uppgörelse i Zweig Memorial ($142.000) tar Åke Svanstedt ut duon <strong>Emira Mil</strong> (e. Face Time Bourbon), 1.10,2*/$63.397, och <strong>Gigi Hanover</strong> (e. Chapter Seven), 1.10,0/$76.657. Startar gör också Marcus Melanders <strong>Kayleigh</strong> (e. Chapter Seven), 1.10,3/$306.745. </p>



<p class="wp-block-paragraph"><strong>Startlista Harry Zweig Memorial ($350.000)</strong><br><em>Treåringar. 1.609 meter autostart:</em></p>



<ol class="wp-block-list">
<li>Chapercraz (e. Crazy Wow) – Joe Bongiorno</li>



<li>Manclane (e. Cantab Hall) – Tyler Buter</li>



<li>Kilmister (e. Chapter Seven) – Brian Sears</li>



<li>French Wine (e. Bar Hopping) – Andy Miller</li>



<li>Country Dagger (e. Crazy Wow) – Jason Bartlett</li>



<li>Cecil Hanover (e. Chapter Seven) – Åke Svanstedt</li>



<li>Ari Ferrari J (e. Walner) – Dexter Dunn</li>



<li>The Gruffalo (e. Chapter Seven) – Scott Zeron</li>



<li>Some Kinda Crazy (e. Crazy Wow) – David Miller</li>
</ol>



<p class="wp-block-paragraph"><strong>Startlista Harry Zweig Memorial ($142.000)</strong><br><em>Treåriga ston, 1.609 meter autostart:</em></p>



<ol class="wp-block-list">
<li>Blonde Bombshell (e. Walner) – David Miller</li>



<li>Gigi Hanover (e. Chapter Seven) – Åke Svanstedt</li>



<li>Royal Filly (e. Chapter Seven) – Tyler Buter</li>



<li>Emira Mil (e. Face Time Bourbon) – Mark MacDonald</li>



<li>Sadie Hanover (e. Chapter Seven) – Scott Zeron</li>



<li>Canterbury Hanover (e. Chapter Seven) – Jeff Gregory</li>



<li>Walner Payton (e. Walner) – Dexter Dunn</li>



<li>Kayleigh (e. Chapter Seven) – Marcus Melander</li>



<li>Usosweet Blue Chip (e. Devious Man) – Marcus Miller</li>
</ol>

Fokustema
Morgonsvepet
Läs senare
Vi möts igen – efter två år
Hästen som vägrar förlora i Halmstad. Draget som spik på jakt efter jackpotmiljonerna på V75. Hotingveckan drar igång. Svanstedt-stjärnans nya miljonlopp. Storhästägare säljer av ikväll. Svensktätt på Enghien. Svanstedt mot Melander!
Detta och mer i lördagens ”Sju nyheter vid sju”.
Detta och mer i lördagens ”Sju nyheter vid sju”.
