
<p class="has-drop-cap">11995 tog ett femårigt svenskfött styrkefenomen sin första stora seger i ett storlopp mot äldre hästar i premiärupplagan av Jämtlands Stora Pris på Östersundstravet. Det var bara början av rader av storloppstriumfer för Åke Svanstedts främsta häst genom tiderna, <strong>Zoogin</strong> (e. Zoot Suit). 25.346.330 kronor fanns på bankboken efter 96 starter (51 segrar) när tävlingsskorna lades på hyllan sommaren 1999. Zoogin besegrade den nybakade Elitloppsvinnaren <strong>Copiad</strong> (e. Texas) i en minst sagt minnesvärd duell. <br>Zoogin är tvåa i historien när det gäller segrar i Jämtlands Stora Pris. Han vann loppet de tre första åren och bara Stig H Johanssons <strong>Victory Tilly</strong> (e. Quick Pay) är värre med fyra triumfer. När Victory Tilly segrade 2006 var det hästens sista start i den långa och mycket framgångsrika karriären.</p>



<p>I eftermiddag är det dags igen för Jämtlandsbanans flaggskepp för äldre hästar och fyra av tränarna bakom årets hästar har vunnit loppet tidigare: Stefan Melander, Robert Bergh, Daniel Redén och Alessandro Gocciadoro. Även tränaren bakom strukne <strong>Brother Bill</strong>, Timo Nurmos, har vunnit Jämtlands Stora Pris.<br>Alessandro Gocciadoro har vunnit de två senaste åren med Elitloppsdeltagaren <strong>Vernissage Grif</strong> (e. Varenne), men i år heter hans hopp <strong>Always Ek</strong> (e. Filipp Roc), som i sin enda start på svensk mark tidigare galopperade bort sig i Åby Stora Pris förra året.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2018/06/readlyexpress2-617x555.jpg" alt="trav, travsport, sulkysport, v75, östersund, readly, express" class="wp-image-24919"/><figcaption class="wp-element-caption">Readly Express efter segern i Jämtlands Stora Pris tillsammans med Timo Nurmos, Jorma Kontio och skötaren Inga Perk. Foto Mathias Hedlund</figcaption></figure>



<p>Löpningsrekordet ståtar <strong>Readly Express</strong> (e. Ready Cash) med – i särklass dessutom. 2018 travade han 1.10,0a/2.140 meter tillsammans med Jorma Kontio. Näst snabbaste vinnaren är Stefan Melanders <strong>Milligan’s School</strong> (e. Yankee Glide), som noterade 1.11,0a med Carl Johan Jepson året efter.</p>



<p><strong>Segerrikaste tränare i Jämtlands Stora Pris:</strong></p>



<ul class="wp-block-list">
<li>Stig H Johansson – 6 (Victory Tilly, Baron Pepper, Formula One)</li>



<li>Åke Svanstedt – 5 (Zoogin, Finders Keepers, Torvald Palema)</li>



<li>Stefan Melander – 4 (Igor Brick, Scarlet Knight, Iceland, Milligan’s School)</li>



<li>Alessandro Gocciadoro – 2 (Vernissage Grif)</li>



<li>Robert Bergh – 2 (Remington Crown, Tsar d’Inverne)</li>



<li>Lutfi Kolgjini – 2 (Glen Kronos, Mosaique Face)</li>



<li>Timo Nurmos – 2 (Chelsea Boko, Realdy Express)</li>



<li>Daniel Redén – 2 (Call Me Keeper, Västerbo Highflyer)</li>
</ul>



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



<p class="has-drop-cap">2Vad bjuds det då på spelmässigt på banan med ett av landets längsta upplopp? 218 meter mäter nämligen slutrakan på Östersundstravet och Sulkysports tipsexpert enkel streckar en häst med hög kapacitet och som kan vara en spetsvinnare trots spår åtta bakom bilen:<br><em>”Till bästa spiken utser vi <strong>Isabelle Cash</strong> (V75-4) som körs av en mycket kvalificerad kusk i ett lärlingslopp och som är härdad i unghästfinaler. Med lopp i kroppen förväntar vi oss leverans!”</em></p>



<p><a href="https://sulkysport.se/spelstugan/v75-tips-ostersund-10-juni/" target="_blank" rel="noreferrer noopener">Här är Sulkysports stora tipsgenomgång med analyser, spetsstrider, systemförslag och ranking av alla hästar.</a></p>



<p><em>Vill du spela V75 tillsammans med Sulkysport finns följande alternativ:</em></p>



<p><a href="https://www.atg.se/andelskungen/spel/206687_V75_2023-06-10_33_5">Sulkysport Lilla V75 – 15 andelar á 75 kr/styck</a></p>



<p><a href="https://www.atg.se/andelskungen/spel/206688_V75_2023-06-10_33_5">Sulkysport V75 – 15 andelar á 150 kr/styck</a></p>



<p><a href="https://www.atg.se/andelskungen/spel/206689_V75_2023-06-10_33_5">Sulkysport Stora V75 – 15 andelar á 250 kr/styck</a></p>



<p>Förutom i Östersund tävlas det även i Vaggeryd (första start 18.30) ikväll, där breddlopp står på programmet.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2023/06/230610.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till dagens tävlingar.</a></p>



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



<p class="has-drop-cap">3Det kryllar av topphästar som startar på Vincennes (första start 13.58) under eftermiddagen. Ur svensk synvinkel får Tomas Malmqvist-tränade <strong>Jazzy Perrine</strong> (e. Django Riff) anses vara den mest intressanta efter hennes uppvisning vid seger i Fyraåringseliten för ston på 1.09,0a/1.640 meter.<br>Idag är förutsättningarna annorlunda då Prix Guy Le Gonidec (€120.000) avgörs över 2.700 meter voltstart, men det är alltjämt bara ston bland konkurrenterna i strid om segerchecken på 54.000 euro där även Jarmo Niskanens <strong>Joyful Diva</strong> (e. Sam Bourbon) finns med.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/05/jazzyperrine1-617x333.jpg" alt="" class="wp-image-449888"/><figcaption class="wp-element-caption">Jazzy Perrine och Tomas Malmqvist efter segern. Foto: Mathias Hedlund/Sulkysport</figcaption></figure>



<p>De jämngamla hingstarna gör i sin tur upp i Prix Jules Thibault (€120.000) med samma förutsättningar och där sticker kullettan <strong>Just A Gigolo</strong> (e. Boccador du Simm) ut.</p>



<p>I Prix Chambon P (€120.000) för den äldre eliten gör Prix de France och Prix de Paris-vinnaren <strong>Ampia Mede Sm</strong> (e. Ganymede) comeback och drabbar samman med fjolårets Harper Hanovers-vinnare <strong>Diable de Vauvert</strong> (e. Prince d’Escape) som gör årsdebut.</p>



<p>Finfrämmat är det även i femåringsloppet Prix Jean Le Gonidec (€120.000) där toppnamn som <strong>Idao de Tillard</strong> (e. Severino) och <strong>Izoard Vedaquais</strong> (e. Bird Parker) drabbar samman.</p>



<p>Inledningsloppet Prix d’Arpajon (€56.000) innehåller tre svenskfödda hästar i form av Jean-Michel Bazire-tränade <strong>Galantis</strong> (e. Zola Boko), Tomas Malmqvists <strong>Digital Dominance</strong> (e. Super Photo Kosmos) samt Björn Goops <strong>Gaylord Am </strong>(e. Muscle Hill).</p>



<p>Svensktränat finns det därtill i evakueringsloppet Prix de Villeneueve-sur-Lot (€40.000) där Tomas Malmqvists danskfödda <strong>Holly Go Lightning</strong> (e. Västerbo Prestige) och Jarmo Niskanens <strong>Jockstrap</strong> (e. Prince Gede) finns bland de 16 deltagarna.</p>



<p><a href="https://sulkysport.se/trav-och-galopp/paris-vincennes-2023-06-10/" target="_blank" rel="noreferrer noopener">Här kan du ta del av dagens startlistor till tävlingarna på Vincennes.</a></p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2020/09/pacificfaceheat-617x333.jpg" alt="" class="wp-image-112131"/><figcaption class="wp-element-caption">Pacific Face och Giuseppe Lubrano. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">4Halmstadtränaren Giuseppe Lubranos stora profilhäst <strong>Pacific Face</strong> (e. igor November), 1.10,4ak/3.175.405 kr, slutade femma vid sin vårcomeback på Jgäersro den 18 maj, men nu kan det dröja lång tid innan den elvaårige valacken syns på en tävlingsbana igen.<br>– Han hade en varning på en böjsena vid kontroll hos veterinär. Han får vila och så får vi se om vi kan göra ett försök till, men hästen är gammal nu, sade Giuseppe Lubrano i Åbys vinnarcirkel under torsdagskvällen.</p>



<p>Pacific Face har fyra 150.000-kronorssegrar på sitt cv och bland dem finns en fullträff i gulddivisionsloppet Arvid Stjernswärds Minne från 2021 då han även slutade tvåa i guldfinalen tre veckor senare.</p>



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



<p class="has-drop-cap">5Killerin Eliitti i Jyväskylä för fyra- och femåriga travare avgörs idag med 25.000 euro till vinnaren och en exporterad svensk unghäststjärna finns bland favoriterna. <strong>Felix Orlando</strong> (e. Orlando Vici) var trea i Svensk Uppfödningslöpning som tvååring och vann dubbla E3-finaler som treåring för Per Nordström.<br>Med en tyngre fyraåringssäsong bakom sig såldes den 3,5-faldige miljonären till Finland i mars och debuten i det nya hemlandet slutade med enkel seger från lendingen i just Jyväskylä för knappt tre veckor sedan.</p>



<p>En svensktränad häst finns me i startfältet, Mattias Djuses <strong>Global Classified</strong> (e. Bold Eagle), 1.11,9ak/785.500 kr, som körs av Jorma Kontio. Denne har vunnit loppet tre gånger tidigare: Glenn Kosmos 1984, Hearts Lobelll 1991 och Cold Hard Wind 2004. <br>Fler hästar med svenskanknytning är fjolårets finska Derbytvåa <strong>Velvet Gold </strong>(e. Maharajah), som då tränades av Timo Nurmos, och svenskfödde <strong>Edima</strong> (e. Love You).</p>



<p><strong>Startlista Killerin Eliitti (€52.500)</strong><br><em>2.140 meter autostart:</em></p>



<ol class="wp-block-list">
<li>Global Classified (e. Bold Eagle).– Jorma Kontio (Mattias Djuse)</li>



<li>Everlasting Boogie (e. Pastor Stephen) – Kenneth Danielsen</li>



<li>Speedy Norwegian (e. Lexus Font) – Olle Koivunen (Kenneth Danielsen)</li>



<li>Edima (e. Love You) – Niko Riekkinen (Timo Hulkkonen)</li>



<li>Mr Stahl (e. Knows Nothing) – Tommi Kylliäinen (Ville Mäkelä)</li>



<li>Felix Orlando (e. Orlando Vici) – Santtu Raitala (Matias Salo)</li>



<li>Shackhills Twister (e. Il Villaggio) – Jari Kinnunen</li>



<li>Velvet Gold (e. Maharajah) – Iikka Nurmonen</li>



<li>Cream Candy (e. The Bosses Lindy) – Emma Väre</li>



<li>Let’s Get It Up (e. All Laid Out) – Hannu Torvinen (Christa Packalén)</li>
</ol>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/06/happyshadowweb-617x333.jpg" alt="" class="wp-image-455988"/><figcaption class="wp-element-caption">Jägersrotränaren Preben Söviks sto Happy Shadow tog karriärens första seger i förstök till Jydsk 4-årings Grand Prix. Foto Kjeld Mikkelsen/KM Foto</figcaption></figure>



<p class="has-drop-cap">6 Igår hölls det försök till Jydsk 4-årings Grand Prix både för hingstar/valacker och ston på Jydsk Vaeddelöbsbana i Århus. En av vinnarna kom från Jägersro och Preben Sövik körde egentränade <strong>Happy Shadow</strong> (e. Orlando Vici-Most Wanted One) till seger och stoet avlade maiden i sin 18:e start efter tidigare räknat in fem andraplatser.</p>



<p>Vinnartiden skrevs till 1.15,1a/1.800 meter och förstapriset uppgick till 15.000 danska kronor. Övriga vinnare bland stona var: <strong>Helena D D </strong>(e. Orlando Vici-Princess Step) och Jeppe Rask på 1.15,2. Jeppe Rask vann också bakom <strong>Hovita </strong>(e. Infinitif-Ovita Bork) på samma tid, medan Bo Westergård körde <strong>Herina Sotto</strong> (e. Love You-Iowa Sund) till vinst på 1.15,4.</p>



<p>Fyra försök hölls också för hingstarna och valackerna över distansen 2.360 meter och hade följande vinnare:</p>



<h2 class="wp-block-heading">Häst (stamtavla) – Körsven – Segertid</h2>



<ul class="wp-block-list">
<li><strong>Hound Dog EP</strong> (e. Victor Gio-Loving You E P) – Nicklas Korfitsen – 1.17,2a</li>



<li><strong>Howlingatthemoon</strong> (e. Cantab Hall-Nobodybeatsthebeat) – Jan Dahlgaard – 1.16,4a</li>



<li><strong>Hnokki Speed </strong>(e. Wishing Stone-Perfect One) – Birger Jörgensen – 1.15,6a</li>



<li><strong>Harboe</strong> (e. Goetmals Wood-Ninth Avenue) – Jeppe Rask – 1.16,7a</li>
</ul>



<p>Finalerna avgörs den 24 och 25 juni.</p>



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



<p class="has-drop-cap">7Det bjuds ut 20 hästar på Traveras lördagsauktion och merparten är starthästar. Mest meriterad av 16 hästar är <strong>Hat Trick</strong> (e. Maharajah), som sprungit in 888.872 kronor och travat 1.10,9ak som snabbast. Lika snabbt har halvmiljonären <strong>Dats Pepito</strong> (e. Panne de Moteur) travat och i kategorin finns exempelvis också <strong>Firefoot</strong> (e. Bold Eagle), som vann V75-lopp förra året.</p>



<p>Två ettåringar med bortgångne <strong>Sebastian K.</strong> som far och två fölston bjuds också ut.</p>



<p><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 ikväll.</a></p>

Fokustema
Morgonsvepet
Läs senare
Vem kan utmana denna kvartett?
Från Zoogin till Vernissage Grif – men Victory Tilly är störst! Malmqvists Solvallavinnare ”tillbaka” på Vincennes. Kariären i fara för flerfaldig miljonär på västkusten. Svensk unghäststjärna mot ny seger i Finland?
Detta och mer i lördagens ”Sju nyheter vid sju”.
Detta och mer i lördagens ”Sju nyheter vid sju”.
