<p><span class="anfang">1</span> När Catarina Norqvists ögonsten <strong>From the Mine</strong> (e. From Above) idag gör sin 80:e start i karriären så blir det samtidigt den första utanför Sveriges gränser.<br />
Tioåringen ska nämligen starta i finska Kaustinen där Festival-ajo (€22.000) avgörs över den engelska milen med 10.000 euro på spel till vinnaren.</p>
<p>Från Umeå går färjan till Vasa varifrån de är knappt 15 mils resväg till Kaustinen där hästen i dagens lopp kommer att köras av Umåkerproffset Samu Sundqvist för allra första gången.<br />
I söndags slutade From the Mine tvåa i sitt genrep i Glada Hudiks Sommarpris på Hagmyren.</p>
<p><strong>Startlista Festival-ajo</strong><br />
<em>1.609 meter autostart, förstapris: 10.000 euro</em></p>
<ol>
<li>Jason&#8217;s Camden – Olli Koivunen</li>
<li>M.S. Triple J. – Ari Moilanen</li>
<li>Farzad Boko – Antti Ala-Rantala</li>
<li>Whole Lotta Love – Hannu Korpi</li>
<li>Next Direction – Hannu Torvinen</li>
<li>Evaluate – Iikka Nurmonen</li>
<li>From the Mine – Samu Sundqvist</li>
<li>Prince Palema – struken</li>
<li>President Lindy – Niko Jokela</li>
<li>Tapiro Jet – Tapio Perttunen</li>
<li>Lake&#8217;s Action – Ville Pohjola</li>
<li>Thai Profit – Santtu Raitala</li>
</ol>
<p style="text-align: center;">***</p>
<p><span class="anfang">2</span></p>
<p>Efter torsdagens uppvisning av <strong>Francesco Zet</strong> (e. Father Patrick) i Sprintermästaren på nya svenska rekordtiden 1.09,4a/1.609 meter avslutas Halmstadtravets Sprintermästarweekend med eftermiddagens STL-tävlingar, ordentligt kryddade med en rejäl jackpot på V75. Nästan 31,5 miljoner kronor extra ligger i sjurättspotten sedan utdelniungen på femmorna uteblivit både i Eskilstuna i lördags och i Halmstad i torsdags.</p>
<p>På Halmstads snabba bana nyttjar Sulkysport en tänkbar spetsvinnare som ett av enkelstrecken:</p>
<p>&#8221;<em><strong>Golden Guard</strong> (V75-2) är kvick från början och som vi läser loppet håller han <strong>Deep Pockets</strong> utvändigt om sig. När det sedan handlar om sprinterdistans tror vi att Claes Svensson spårar hela vägen i silverdivisionen</em>.&#8221;</p>
<p><a href="https://sulkysport.se/spelstugan/v75-tips-hela-vagen/" target="_blank" rel="noopener">Här är den stora tipsgenomgången med analyser, spetsstrider och ranking av alla hästar!</a></p>
<p>Fjolårets Sprintermästare <strong>Önas Prince</strong> (e. Chocolatier) dyker upp i Halmstad i eftermiddag, men han gör det inte i dagens bästa lopp gulddivisionen. Istället väljer Per Nordström ett femåringslopp, där Önas Prince ställs mot blott fyra konkurrenter.</p>
<p>Gulddivisionen ser istället tre andra av årets Elitloppsdeltagare: <strong>Night Brodde </strong>(e. Up And Quick), <strong>Brother Bill </strong>(e. From Above) och <strong>Admiral As</strong> (e. Ready Cash), där ingen i trion hade speciell tur i spårlottningen. Night Brodde drog sjundespår bakom bilen medan de övriga tvingas inleda från bakspår.</p>
<p>Att det kan travas fort även över medeldistans på Halmstads oval har gulddivisionsloppet visat genom åren och Sulkysport har plockat fram samtliga vinnare som sprungit under 1.12.</p>
<h2>År, vinnare (far) – Segertid – Kusk (tränare)</h2>
<ul>
<li><strong>2017</strong> Ringostarr Treb (e. Classic Photo) – 1.10,5ag – Wim Paal (Jerry Riordan)</li>
<li><strong>2015</strong> El Mago Pellini (e. Chocolatier) – 1.11,0a – Adrian Kolgjini (Lutfi Kolgjini)</li>
<li><strong>2013</strong> Monster Drive (e. Thai Tanic) – 1.11,3a – Björn Goop (Reijo Liljendahl)</li>
<li><strong>2012</strong> Yield Boko (e. Viking Kronos) – 1.11,4a – Örjan Kihlström (Stefan Hultman)</li>
<li><strong>2014</strong> Orecchietti (e. From Above) – 1.11,4a – Örjan Kihlström (Stefan Hultman)</li>
<li><strong>2021</strong> Cyber Lane (e. Raja Mirchi) – 1.11,5a – Johan Untersteiner</li>
<li><strong>2019</strong> Cyber Lane (e. Raja Mirchi) – 1.11,8a – Johan Untersteiner</li>
<li><strong>2010</strong> Infatti November (e. Viking Kronos) – 1.11,9a – Erik Adielsson (Stig H Johansson)</li>
</ul>
<p><em>Fotnot: Distansen är 2.140 meter med autostart.</em></p>
<p style="text-align: center;">***</p>
<p><span class="anfang">3</span></p>
<p>Igår satte Lycksele punkt för årets tävlingssäsong – i dag kliver Hoting (första start 13.15) in. Det är årspremiär på den idylliska banan i nordöstra Jämtlands län och för första gången sedan 2019 blir det publik på plats. 2020 valde arrangörerna att ställa in travveckan helt och hållet på grund av pandemin och ifjol hölls de utan publik med anledning av restriktionerna.</p>
<p>Men idag dukas det upp till premiärfest – och som Hotingtravets ordförande Sven-Olof Lindman skriver i banprogrammet till dagens tävlingar: &#8221;Jag tror inte att vårt samhälle, Hoting med omnejd, har längtat så mycket efter något så mycket som vår kära &#8221;travvecka&#8221;. Vi körde visserligen travveckan förra året, men då utan publik och det var en upplevelse i sig, inte att förakta, men trav ska avnjutas i sommarväder med både många på publikplats, bra tävlingar och en god stämning!&#8221;</p>
<p>Hotings tävlingsschema fortsätter på tisdag med kvällstrav och avslutas på fredag med lunchtävlingar. Premiären ser bland annat två av landets segerikaste kuskar, Mats E Djuse och Rikard N Skoglund, i startlistorna både idag och på tisdag. Rikard har dubbla championat på banan sedan tidigare och kanske gör en attack mot ett tredje?</p>
<p>En annan sommarbana tävlar också denna lördag när kvällsbegivenheterna sker på Åland i Mariehamn (start 18.30), där årets andra och sista tävlingsdag håll. Som vanligt med många svenska hästar på plats och mer än hälften av de 70 startande hästarna tar någon av färjorna över från Sverige.</p>
<p>Snabbloppet över sprinterdistans med startbil ser bland annat nästan sexfaldige miljonären <strong>Yes Mickey</strong> (e. Muscle Hill) i comeback efter några månaders uppehåll. Yes Mickey, som är halvbror till avelshingsten <strong>Adrian Chip</strong> (e. Andover Hall), tjänade merparten av sina pengar i regi Åke Svanstedt i USA – vann Zweig Memorial ($320.000) som treåring – innan han kom till Robert Bergh på hösten som femåring. Sedan förra sommaren tränas han av Nina Pettersson-Perklen.</p>
<p><a href="https://sulkysport.se/wp-content/uploads/2022/07/220709.pdf" target="_blank" rel="noopener">Här är startlistorna till lördagens tävlingar.</a></p>
<p style="text-align: center;">***</p>
<p><span class="anfang">4</span> På Enghien (13.58) syns flitigt med svenskkopplade bidrag under eftermiddagen. Två Grupp III-lopp finns inom det nio lopp stora tävlingsprogrammet bland vilket Prix de Rome (€80.000) för europeiska treåringar utgör ett.<br />
Tomas Malmqvist selar ut en trio i form av <strong>Jazzy Dancer</strong> (e. Django Riff), <strong>Jasmin de Vallon</strong> (e. Royal Dream) samt<strong> Jail Break</strong> (e. Bold Eagle) i jakten på de 36.000 euro som vinnaren kammar hem.</p>
<figure id="attachment_140036" aria-describedby="caption-attachment-140036" style="width: 2560px" class="wp-caption alignright"><a href="https://sulkysport.se/wp-content/uploads/2021/02/criteriumdes3ans3-scaled.jpg"><img class="size-full wp-image-140036" src="https://sulkysport.se/wp-content/uploads/2021/02/criteriumdes3ans3-scaled.jpg" alt="" width="2560" height="1886" /></a><figcaption id="caption-attachment-140036" class="wp-caption-text">In the Money och Thierry Duvaldestin spurtar hem Criterium des Jeunes förra året. Foto: Gerard Forni</figcaption></figure>
<p>Det andra Grupp III-loppet är det kombinerade fyra- och femåringsloppet Prix du Louvre (€80.000). Björn Goops <strong>Buena Suerte Bi</strong> (e. Yankee Glide) finns bland de tio deltagarna i loppet som även innehåller den forne, finske Kriterievinnaren Sahara Jaeburn (e. Ready Cash) samt Thierry Duvaldestins tvååringsstjärna <strong>In The Money</strong> (e. Cristal Money).<br />
Den sistnämnde besegrade de bästa i sin kull i Grupp I-klassade Criterium des Jeunes (€170.000) i februari 2021, men har inte startat sedan han slutade nia i Prix Albert Viel (€170.000) under fjolårets midsommarhelg.</p>
<p>I High Five-loppet Prix de la Manche (€90.000) syns en svenskfödd duo i form av Jarmo Niskanen-tränade<strong> Cyrano de B.</strong> (e. S.J.&#8217;s Caviar) liksom Jean-Michel Bazires <strong>Belker</strong> (e. Scarlet Knight) och så har Niskanen även med den av Mattias Djuse-ägde <strong>Icare Williams</strong> (e. Carat Williams) i montéloppet Prix d&#8217;Armenieres (€44.000).</p>
<p style="text-align: center;">***</p>
<p><span class="anfang">5</span> Det travas även i Vichy (19.15) på fransk mark och där avgörs semi classique-loppet Grand Prix du Conseil Municipal (€120.000) med flera bekanta namn i startlistan.<br />
Svenskfödde <strong>Tjacko Zaz</strong> (e. Crazed) tillmäts ingen större chans på förhand utan här är det stallkamraterna <strong>Rebella Matters</strong> (e. Explosive Matter) och <strong>Elie de Beaufour</strong> (e. Royal Dream) som tillmäts betydligt större vinstchans.</p>
<p><strong>Startlista Grand Prix du Conseil Municipal</strong><br />
<em>2.950 meter voltstart, förstapris: 54.000 euro</em></p>
<ol>
<li>Tjacko Zaz – Tristan Ouvrie</li>
<li>Eddy du Vivier – Cedric Terry</li>
<li>Copsi – Dominik Locqueneux</li>
<li>Echo de Chanlecy – Tony Le Beller</li>
<li>Victor Ferm – Pierre Vercruysse</li>
<li>Diablo de Caponet – Alexandre Abrivard</li>
<li>Freyja du Pont – Damien Bonne</li>
<li>Jerry Mom – Jean Etienne Abrivard (+25 meter)</li>
<li>Rebella Matters – David Bekaert</li>
<li>Elie de Beaufour – Jean Michel Bazire</li>
</ol>
<p style="text-align: center;">***</p>
<p><span class="anfang">6</span> Sent ikväll – 23.20 – avgörs Grupp III-klassade Gran Premio Riccardo Grassi (€40.400) i italienska Cesena och det sker med gott om bekanta deltagare även för den blågula publiken.</p>
<figure id="attachment_37361" aria-describedby="caption-attachment-37361" style="width: 1500px" class="wp-caption aligncenter"><a href="https://sulkysport.se/wp-content/uploads/2019/01/giveitgasandgoheat.jpg"><img class="size-full wp-image-37361" src="https://sulkysport.se/wp-content/uploads/2019/01/giveitgasandgoheat.jpg" alt="Giveitgasandgo" width="1500" height="800" /></a><figcaption id="caption-attachment-37361" class="wp-caption-text">Giveitgasandgo. Foto Mia Törnberg/Sulkysport</figcaption></figure>
<p>Alessandro Gocciadoros svenskfödde nioåring <strong>Global Trustworthy</strong> (e. Muscle Hill) gör sin första start sedan februari, möter den norskfödde stallkamraten <strong>Chief Orlando</strong> (e. Orlando Vici) samt 2018 års vinnare av Fyraåringseliten <strong>Giveitgasandgo</strong> (e. Yankee Glide) som numera finns i Holger Ehlerts regi.</p>
<p><strong>Startlista Gran Premio Riccardo Grassi </strong><br />
<em>1.660 meter autostart, förstapris: 14.232 euro</em></p>
<ol>
<li>Ursus Caf – Manuel Pistone</li>
<li>Amon You Sm – Vincenzo P.Dell&#8217;Annuziata</li>
<li>Apple Wise As – Antonio Greppi</li>
<li>Global Trustworthy – Marco Stefani</li>
<li>Chief Orlando – Carmine Piscuoglio</li>
<li>Achille Blv – Enrico Bellei</li>
<li>Trillo Park – Antonio Velotti</li>
<li>Bonjovi Mmg – Maurizio Cheli</li>
<li>Giveitgasandgo – Roberto Vecchione</li>
<li>Akela Pal Ferm – Antonio di Nardo</li>
</ol>
<p style="text-align: center;">***</p>
<p><span class="anfang">7 </span>Efter att Jarlsberg (14.10) flyttat finalen av stoavdelningen i Jarlsberg Grand Prix till söndagen detta år så körs det istället V75-finaler på banan under eftermiddagen.<br />
Samtliga lopp har 100.000 norska kronor i förstapris och innehåller givetvis flera profilhästar.</p>
<p>I Silverdivisionens final syns de två senaste årens vinnare av Norskt Travderby för ston bland de nio deltagarna då det norska klassystemet är utformat på ett sådant vis att norskfödda ston även får delta i silverklassen.<br />
<strong>Lucky Queen Soa</strong> (e. Make It Happen) som vann år 2020 möter fjolårsvinnaren <strong>Global Bred To Win</strong> (e. Bold Eagle) och ett annat mycket spännande sto syns i finalen av Stodivisionen då Frode Hamre selar ut <strong>Tipsy Bartender</strong> (e. Bar Hopping).<br />
Tillsammans med Erik Adielsson vann USA-importen på 1.13,3a/2.140 meter på Solvalla under Elitloppsfredagen, men dag är det Frode Hamre själv som sitter bakom det treåriga stoet.</p>
