
<p class="has-drop-cap wp-block-paragraph">1Daniel Redéns sto <strong>Delicious</strong> (e. Cantab Hall) satte världsrekord för ston på 1.000-metersbana när hon en augustikväll 2015 tillsammans med Örjan Kihlström travade 1.08,6a/1.640 meter i Bollnäs. I eftermiddag står hälsingebanan i fokus med veckans V75-omgång och banans storlopp för äldre hästar, nämligen Bollnäsloppet.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2017/03/deliciousu.s.aln-617x333.jpg" alt="" class="wp-image-3823"/><figcaption class="wp-element-caption">Delicious U.S. världsrekordlopp i Bollnäs 2015. Foto Christer Norin/ALN</figcaption></figure>



<p class="wp-block-paragraph">Sprinterdistans och startbil är förutsättningarna och det utlovas en bonus på 500.000 kronor om något av de aktuella världsrekorden förbättras.</p>



<p class="wp-block-paragraph"><strong>Det handlar om:</strong></p>



<ul class="wp-block-list">
<li>Äldre hingstar/valacker: <strong>Sebastian K.</strong> (e. Korean) – 1.07,7a/1.609 meter – 2014</li>



<li>Äldre ston: <strong>Manchego</strong> (e. Muscle Hill) – 1.08,1a/1.609 meter – 2020</li>
</ul>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/den-visan-har-man-hort-i-tio-ar/" target="_blank" rel="noreferrer noopener">Här är historien om Sebastian K.s världsrekord för tio år sedan!</a></p>



<p class="wp-block-paragraph">Ingen lätt uppgift förstås för de tio hästarna bakom bilen i årets upplaga, där Alessandro Gocciadoro drog vinstlotten med <strong>Diamond Truppo</strong> (e. Varenne), som vann försök och slutade trea i finalen av Sweden Cup på 1.09,6ak.<br>– Han kommer väl förberedd inför det här loppet. Jag lägger mig inte i taktiken när en duktig kusk som Magnus A Djuse kör, men det finns mycket god startsnabbhet i hästen och jag tror han tar ledningen om kusken vill. Det blir jänkarvagn, barfota runt om och norskt huvudlag, säger Alessandro Gocciadoro.</p>



<p class="wp-block-paragraph">Örjan Kihlström körde Delicious till världsrekord och sitter upp bakom <strong>Mister Hercules</strong> (e. Trixton) från spåret utvändigt.<br>– Mister Hercules gjorde det bra som tvåa bakom San Moteur i Eskilstuna. Från ett bra läge bör han vara en av som gör upp om segern, säger Örjan Kihlström.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/fokus/utvilad-kihlstrom-pa-jakt-efter-nya-segrar/" target="_blank" rel="noreferrer noopener">Läs hela intervjun med Örjan om storloppssegrar, motståndare, Phil Mickelson, loppet han helst vill vinna och mycket mer här.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">2Anders Wallins kallblodige segermaskin <strong>Ulvsåsen</strong> (e. Åsajerven) har kommit tillbaka fenomenalt i år efter långt uppehåll på grund av gaffelbandsskada. Efter tre raka segrar bröts dock sviten i senaste starten när <strong>Månlykke A.M.</strong> (e. Månprinsen A.M.) blev för tuff sista biten. Nu jagar Ulvsåsen revansch tillsammans med Per Linderoth.<br>– Ulvsåsen har varit fin hela tiden sedan han började starta som treåring och senast var han också bra. Jag körde under 1.22 sista och normalt trodde jag att det skulle räcka på krävande bana, men Månlykkes prestation var väldigt bra. Nu är loppet stängd för de bästa och vi har inte så många sådana att välja, säge en optimistisk Per Linderoth.</p>



<p class="wp-block-paragraph">Sulkysports expert lutar sig mot ett singelstreck, hårt betrodda Mahala i diamantstoet, men lyfter fram fler hästar:<br><em>”Ett av de stora hemmahoppen under dagen är Tomas Petterssons <strong>From The Hip</strong> (V75-2). Han kan vara en rolig chansspik för de lite mindre systemen, liksom <strong>Portofino</strong> (V75-6) om man vill halvera systemet. Där dubblar vi nämligen Fredrik B Larssons häst med lägesgynnade <strong>Always A Pleasure</strong> som jagar revansch för galoppen i lördags.”</em></p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/spelstugan/v75-tips-bollnas-27-juli/" target="_blank" rel="noreferrer noopener">––> Här är hela tipsgenomgången med analyser, spetsbud, spikar, drag och ranking av alla hästar.</a></p>



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



<p class="wp-block-paragraph"><a href="https://www.atg.se/andelskungen/spel/206687_V75_2024-07-27_12_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-27_12_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/2024/07/situationship1372024lisa-617x346.jpg" alt="" class="wp-image-609147"/><figcaption class="wp-element-caption">Åke Svanstedt och Situationship vann den ena divisionen i Stanley Dancer Memorial. Foto: Lisa Photo</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">3 99:e upplagan av Hambletonian Stakes ($1.050.000) och den 54:e editionen av Hambletonian Oaks ($525.000) är under uppsegling. I natt svensk tid tävlas det om tio finalplatser i respektive löpning på Meadowlands i East Rutherford.</p>



<p class="wp-block-paragraph">Åtta svensktränade travare tar chansen i försöken i Hambletonian Stakes ($100.000) och de fem främsta från varje försök går vidare till finalen:</p>



<ul class="wp-block-list">
<li><strong>Amazing Catch</strong> (e. Walner) – Åke Svanstedt</li>



<li><strong>Daiquiri Hanover</strong> (e. Bar Hopping) – Åke Svanstedt</li>



<li><strong>Karl</strong> (e. Tactical Landing) – Nancy Takter</li>



<li><strong>Life On the Bluf </strong>(e. Walner) – Lucas Wallin</li>



<li><strong>Security Protected</strong> (e. Father Patrick) – Marcus Melander</li>



<li><strong>Situationship</strong> (e. Chapter Seven) – Åke Svanstedt</li>



<li><strong>Supernova Hanover</strong> (e. Greenshoe) – Per Engblom</li>



<li><strong>Wild Ticket</strong> (e. Chapter Seven) – Marcus Melander</li>
</ul>



<p class="wp-block-paragraph">Fem ston tränas av svenskar i Hambletonian Oaks ($50.000) och de tre främsta från varje försök plus den vinstrikaste fyran är kvalificerade för finalen:</p>



<ul class="wp-block-list">
<li><strong>Date Night Hanover</strong> (e. Chapter Seven) – Marcus Melander</li>



<li><strong>French Champagne </strong>(e. Muscle Hill) – Åke Svanstedt</li>



<li><strong>Senorita Palema </strong>(e. Chapter Seven) – Åke Svanstedt</li>



<li><strong>Soiree Hanover </strong>(e. Walner) – Lucas Wallin</li>



<li><strong>Warrawee Michelle</strong> (e. Walner) – Åke Svanstedt</li>
</ul>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/karl-pa-ratt-spar/" target="_blank" rel="noreferrer noopener">Här är startlistorna till försöken till Hambletonian Stakes och Hambletonian Oaks.</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/2024/01/prixboldeagle3-617x411.jpg" alt="" class="wp-image-546496"/><figcaption class="wp-element-caption">Jushua Tree. Foto Gerard Forni.</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">4OS är i full gång i Paris, men någon vila från travsporten blir det inte. Idag dukar Paris-banan Enghien (första start 13.23) upp för storlopp och ett högintressant besök av en av de hetaste kandidaterna till segern i Prix d’Amérique i januari. Det handlar om Jean-Michel Bazires toppfemåring <strong>Jushua Tree</strong> (e. Bold Eagle), 1.09,8am*/€722.150, som inte har inte synts till på tävlingsbanan sedan han galopperade dubbelt i ett lopp på Vincennes i februari.</p>



<p class="wp-block-paragraph">Nu väntar grupp II-loppet Prix Jean-Luc Lagardere (€150.000) över 2.875 meter, men räkna med ett försiktigt upplägg. Jushua Tree är anmäld med skor.</p>



<p class="wp-block-paragraph">Bland motståndarna finns toppstoet <strong>Ampia Mede Sm</strong> (e. Ganymede), som bytt Fabrice Souloy mot Thierry Duvaldestins i vår och var trea i Prix de Washington (€120.000) i sin comeback. Philippe Allaires tar ut euromiljonären <strong>Just A Gigolo</strong> (e. Boccador de Simm), som var femma i samma lopp.</p>



<p class="wp-block-paragraph">Ingen svensktränad häst startar på Enghien.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/trav-och-galopp/enghien-2024-07-27/" target="_blank" rel="noreferrer noopener">Här är startlistorna till tävlingarna i Paris.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">5Igår var det midnattstrav både på Romme och i Halmstad. Ikväll går turen till Småland och Kalmar (första start 19.30). Där är den sportsliga höjdaren försök- och finalloppet Sommarduellen, där finalvinnaren plockar hem fina 75.000 kronor.</p>



<p class="wp-block-paragraph">I den högre klassen plockar Christoffer Eriksson ut <strong>Liberty Boko</strong> (e. Muscle Hill), som ropades in av Sijoitusyhtiö Aivan Varma Oy på en Traveraauktion i april för 210.000 kronor. Hästen av varit både tvåa och trea i STL-lopp, men väntar på på första fullträffen sedan november 2022 då han tränades av Robert Bergh.</p>



<p class="wp-block-paragraph">En motståndare med snygg resultatrad och många startpoäng är hemmahästen <strong>M.T.Sanches</strong> (e. Ken Warkentin). 1–1–1–3–2 lyder resultatraden i de fem senaste starterna efetr att ha varit fyra som bäst i de sex starterna tidigare under året. M.T.Sanches har tävlat under sadel i de fem senaste starterna och verkligen funnit sig tillrätta i den disciplinen. Håller form och segeraptit i sig när det blir sulky igen?</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2024/07/240727.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/05/evartti2-1-617x333.jpg" alt="" class="wp-image-450189"/><figcaption class="wp-element-caption">Evartti och tränaren Antti Ojanperä. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">6I Finland riktas alla blickar mot Jyväskylä i helgen när finnhästarnas kung och drottning ska koras i Kungstravet. Hingstklassen har dock drabbats av ett tungt avbräck när titelförsvararen <strong>Parvelan Retu</strong> (e. Liising) inte kan vara med. Hästen, som vunnit 53 av 72 starter, har fått en lättare känning i ett framben och tränaren Petri Laine vill inte ta några risker. Laine är besviken att inte kunna vara med, men glad att skadan upptäcktes i tid, rapporterar Ravinetti.</p>



<p class="wp-block-paragraph">Det stora namnet är fjolårets Elitkampvinnare och euromiljonären <strong>Evartti</strong> (e. K.M.Nopsa), som hade tre raka titlar innan Parvelan Retu segrade förra året. En tuff utmanare är blott sjuårige <strong>V.G.Voitto</strong> (e. Viesker), som i Mikkeli travade 1.18,2a/1.609 meter när han spurtslog Evartti och Parvelan Retu. </p>



<p class="wp-block-paragraph">Idag tävlar hästarna över medeldistans. I morgon väntar först ett sprinterlopp och sedan avslutas Kungstravet över 3.100 meter. Den bästa sammanlagda tiden avgör vinnaren.</p>



<p class="wp-block-paragraph">Tyvärr blir det bara nio hästar i årets upplaga, sedan två av elva anmälda redan strukits.</p>



<p class="wp-block-paragraph">Redan igår kväll var det storlopp på varmblodssidan när Jyväskylä värmde upp inför helgens folkfest med fyra- och femåringsloppet Killerin Eliitti (€35.000) med 17.000 euro till vinnaren. </p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/07/202407261819240m3a0481-617x412.jpg" alt="" class="wp-image-614617"/><figcaption class="wp-element-caption">Massimo Hoist vinner för Mika Forss. Foto: Terhi Piispa-Helisten</figcaption></figure>



<p class="wp-block-paragraph">Den prischecken lade Jukka Hakkarainen-tränade <strong>Massimo Hoist</strong> (e. Muscle Hill) och Mika Forss beslag på efter att ha travat 1.12,9a/2.140 meter på en regnblöt oval.<br>Massimo Hoist svarade för en toppinsats när han via tredjespår i första sväng gjorde ett rejält speedryck på första långsidan för att nå ledningen. Sedan hölls tempot uppe hela vägen, men Massimo Hoist vägrade släppa någon förbi sig när han tog en säker seger före gott avslutande <strong>Crepe Match</strong> (e. Creatine). <strong>Need’em</strong> (e. Propulsion var bäst av tre svenskfödda i loppet som trea.</p>



<p class="wp-block-paragraph">Massimo Hoists främsta merit är tredjeplatsen i finska Derbyt förra året och totalt har han vunnit elva av 28 starter.</p>



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



<p class="has-drop-cap wp-block-paragraph">715 starthästar finns bland de 21 hästarna i den digitala katalogen till Traveras internetauktion ikväll. En av dem är Åke Lindblom-tränade femåringen <strong>Nail’em </strong>(e. Tixton), som vunnit sex lopp och springit in drygt 650.000 kronor. Hästen slutade trea i ett V75-lopp på Axevalla så sent som i lördags.</p>



<p class="wp-block-paragraph">Framtidskapitalen är tre ettåringar (e. Credit Winner, Mosaique Face och Power), en tvååring (e. Quid Pro Quo) och två toppstammade, intressanta fölston. <strong>Bagatelle</strong> (e. Love You) är dräktig med San Moteur) och <strong>Dancin In the Rain</strong> (e. Muscle Hill) är dräktig med Calgary Games. </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
Lockar en halv miljon till rekordjakt?
Världsrekordförsök med nio 1.09-travare. Linderoth förhoppningsfull bakom Ulvsåsen. Alla svenskar i Hambokval. Bazires Pd'A-hopp gör comeback. Skadad titelförsvarare missar Kungstravet. 21 hästar till salu ikväll.
Detta och mer i lördagens ”Sju nyheter vid sju”.
Detta och mer i lördagens ”Sju nyheter vid sju”.
