
<p class="has-drop-cap">1 Det kryllar som vanligt av blågula hopp på Vincennes under Prix d&#8217;Amerique-helgen.<br>Totalt finns det 31 deltagare som på ett eller annat sätt har blågul koppling vad gäller hästens ursprung för häst, kusk eller eller tränare.</p>



<p>Av dem startar 20 under söndagens mer penningstinna tävlingar och övriga 13 kommer till start under lördagen.</p>



<h2 class="wp-block-heading">Svenska hopp under lördagen:</h2>



<ul class="wp-block-list">
<li>Prix Offshore Dream (€39.000): <strong>Icarus Bourbon</strong> (e. Prodigious) – Yoann Lebourgeois (Björn Goop).</li>



<li>Prix des Andelys (€33.000): <strong>Invader Am</strong> (e. Muscle Hill) – Alexandre Abrivard (Laurent Claude Abrivard).</li>



<li>Prix de Chalons En Champagne (€39.000): <strong>Miss Jaja</strong> (e. Prodigious) – Alexandre Abrivard (Laurent Claude Abrivard), <strong>Junkie</strong> (e. Varenne) – Thomas Levesque (Erik Bondo).</li>



<li>Prix du Luxembourg (Gr III, €100.000): <strong>Milliondollarrhyme</strong> (e. Ready Cash) – Franck Nivard (Fredrik B Larsson), <strong>Dear Friend </strong>(e. Orlando Vici) – Örjan Kihlström (Marcus Lindgren), <strong>Usain Töll</strong> (e. Googoo Gaagaa) – Vincenzo P.Dell&#8217;Annunziata (Gennaro Casillo), <strong>Ferrari Sisu </strong>(e. Djali Boko) – Conrad Lugauer.</li>



<li>Prix Roquepine (Gr II, €150.000): <strong>Kalicia Josselyn </strong>(e. Follow You) – Eric Raffin (Tomas Malmqvist).</li>



<li>Prix de Vittel (€65.000): <strong>Crack Atout</strong> (e. Niky) – Gabriele Gelormini (Tomas Malmqvist).</li>



<li>Prix Paul Viel (Gr II, €150.000): <strong>Kamehameha</strong> (e. Uniclove) – Eric Raffin (Tomas Malmqvist).</li>



<li>Coupe d&#8217;Europe des Amateurs (€15.000): <strong>Gloire de Fleury </strong>(e. Reve de Beylev) – Peter Arnqvist (Martial Dupuis).</li>



<li>Prix Varenne (€44.000): <strong>Istania de Viette </strong>(e. Carat Williams) – Yoann Lebourgeois (Marie Norberg).</li>
</ul>



<h2 class="wp-block-heading">Svenska hopp under söndagen:</h2>



<ul class="wp-block-list">
<li>Prix de Meadowlands (€61.000): <strong>Justess Viking</strong> (e. Ubriaco) – Marie Norberg.</li>



<li>Prix WTW Hipcover Assurances Hippiques (€61.000): <strong>Jack l&#8217;Eventreur </strong>(e. Oardo) – Örjan Kihlström (Björn Goop).</li>



<li>Prix Ourasi (Gr I, €300.000): <strong>Joyful Diva</strong> (e. Sam Bourbon) – Franck Nivard (Jarmo Niskanen), <strong>Jazzy Perrine</strong> (e. Django Riff) – Eric Raffin (Tomas Malmqvist).</li>



<li>Prix Camille Blaisot (Gr II, €120.000): <strong>Intuition</strong> (e. Brillantissime) – Adrien Lamy (Tomas Malmqvist).</li>



<li>Prix d&#8217;Amerique (Gr I, €1.000.000): <strong>Honey Mearas </strong>(e. Readly Express) – Örjan Kihlström (Daniel Redén), <strong>Moni Viking</strong> (e. Maharajah) – Björn Goop, <strong>Don Fanucci Zet </strong>(e. Hard Livin) – Yoann Lebourgeois (Daniel Redén).</li>



<li>Prix Helen Johansson (Gr III, €90.000):<strong> Iceland Falls </strong>(e. Iceland) – Björn Goop (Fredrik Wallin).</li>



<li>Prix Bold Eagle (Gr I, €300.000):<strong> Invictus Madiba</strong> (e. Booster Winner) – Adrien Lamy (Tomas Malmqvist), <strong>Isla Jet </strong>(e. Bold Eagle) – Eric Raffin (Tomas Malmqvist) – <strong>Imhatra Am</strong> (e. Muscle Hill) – Björn Goop (Jörgen Westholm).</li>



<li>Prix Jean Rene Gougeon (Gr III, €90.000): <strong>Bordeaux S.</strong> (e. Orlando Vici) – Jean Michel Bazire, <strong>Belker</strong> (e. Scarlet Knight) – Yoann Lebourgeois (Björn Goop), <strong>Cyrano de B. </strong>(e. S.J.&#8217;s Caviar) – Franck Ouvrie (Jarmo Niskanen), <strong>Oracle Tile</strong> (e. Ready Cash) – Clément Duvaldestin (Thierry Duvaldestin), <strong>Eric the Eel </strong>(e. Muscle Hill) – Adrien Lamy (Tomas Malmqvist).</li>
</ul>



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



<p class="has-drop-cap">2 I lördags vann Bergsåkeramatören Ola Åsebös toppkallblod <strong>Soldhöjdens Drake</strong> (e. Lome Brage) kallblodsloppet inom Östersunds V75-omgång tillsammans med Torbjörn Jansson. Redan ikväll på Romme (första start 18.20) är ekipaget tillbaka i ett litet men naggande gott kallblodslopp, som är kvällens höjdare på dalabanan.</p>



<p>Soldhöjdens Drake har under unghäståren tillhört absoluta kulltoppen i landet (bland annat fyra i Derbyt) och fortsatte ta kliv ifjol som femåring. 2023 började på bästa sätt med seger och Soldjöjdens Drake visade att han är redo tuffare motstånd.</p>



<p>I kallblodsloppet på Romme, som är stängt vid 1,5 miljoner kronor, stöter han på flera starka namn i klassen. Som Alf Jonssons <strong>Tekno Jerven</strong> (e. Tekno Odin), som galopperade som favorit i Östersund efter bland annat seger i kallblodsdivisionens final före jul med just Soldhöjdens Drake som tvåa, och forne Kriterievinnaren <strong>Bäcklös Uriel </strong>(e. Smedheim Solan), som vann Helge Solos lopp inom V75 i början av året.</p>



<p>Ett spännande lopp med svenska kallblod som vill växa i i eliten!</p>



<figure class="wp-block-image aligncenter size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2021/08/soldhojdensdrake-617x333.jpg" alt="" class="wp-image-204713"/><figcaption class="wp-element-caption">Soldhöjdens Drake och Torbjörn Jansson. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



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



<p class="has-drop-cap">3 Den tyska storhästägaren Karin Walter-Mommert har inte mindre än 66 hästar i träning hos svenska proffstränare i nuläget.<br>I söndags anslöt fyra stycken till Halmstads Håkan K Persson som därmed tränar sex hästar åt Walter-Mommert.</p>



<p>Den åttaårige Sam Bourbon-sonen <strong>Emilion</strong>, 1.12,3ak/762.555 kr är den mest meriterade av dem, men även femårige valacken <strong>Goop</strong> (e. Love You) 1.13,5am/184.198 kr sticker ut då han vann fyra lopp på svensk mark under fjolåret och kvalificerade sig för finalen av Danskt Travderby (oplacerad).<br>De övriga två förvärven är tyskfödde sjuåringen <strong>Jaxon Schermer </strong>(e. Varenne) 1.12,5ak/230.177 kr samt fyraårige, holländske Propulsion-sonen <strong>Mega Occagnes</strong>, 1.17,0am/18.963 kr.</p>



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



<p class="has-drop-cap">4 Romme (första start 18.20) är fredagens huvudbana och utanför V64-kupongen dyker Sveriges segerrikaste montéhäst 2022 upp för att göra årsdebut. Med nio segrar på 13 starter var nämligen<strong> Linus Boy</strong> (e. Zola Boko), ägd och tränad av Rommeamatören Catarina Westlund Grahn, bäst i klassen under sadel sett till antalet segrar.</p>



<p>Sveriges montéchampion Jonathan Carre satt allt som oftast i sadeln och gör så även i kvällens start, där Linus Boy inleder från 40 meters tillägg i ett sjuhästarsfält. Linus Boy avslutade fjolåret med tre raka segrar.</p>



<p>Kalmar (första start 12.20) har hand om lunchtävlingarna. Christoffer Eriksson gästar med en häst, Ready Cash-dottern <strong>Beauty Smart Face</strong>, som i sitt livs tredje start på sommaren som treåring vann på starka 1.13,9a/2.140 meter. Sedan dröjde nästa seger till årsdebuten på Åby för två veckor sedan, men det finns gott kunnande i det fyraåriga stoet. Precis som senast är uppgiften 20 meters tillägg i ett stolopp.</p>



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



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



<p class="has-drop-cap">5 Fjolårets danska Derbystovinnare <strong>Golden C N </strong>(e. Wishing Stone) gör under seneftermiddagen debut i nygammal regi.<br>Det nu femåriga stoet är tillbaka hos Bent Svendsen efter en sejour hos Flemming Jensen för vilken hon vann just Derbystoet, men stoet har ett starkt cv och vann även Dansk Uppfödningslöpning mot &#8221;pojkarna&#8221; som tvååring.</p>



<p>I dagens lopp drabbar stoet samman med stallkamraten <strong>Come On Hugo</strong> (e. Dream Vacation) som Bent Svendsen nyttjar Knud Mönster som chaufför bakom, men även svenskbekante <strong>Express A P </strong>(e. S.J.&#8217;s Caviar) är värd att nämna.</p>



<p><a href="https://www.epaper.dk/danskhv/aalborg/aalborg_27-01-23/" target="_blank" rel="noreferrer noopener">Här kan du ta del av dagens startlistor till tävlingarna i Ålborg.</a></p>



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



<p class="has-drop-cap">6 Tomas Petterssons<strong> Exposed Sox</strong> (e. Face Time Bourbon) blev vid gårdagens från Gävle till Solvalla-flyttade tävlingar den sjätte treåringen att vinna lopp på en svensk travbana under detta år.<br>Segern var värd 25.000 kronor, togs på 1.18,6/2.140 meter och Exposed Sox blev därmed Face Time Bourbons femte svenskfödda avkomma att vinna lopp.</p>



<p>Stoet var den femte dyraste hästen då hon såldes på Åby Yearling &#038; Mixed Sales år 2021 när klubban slog på 650.000 kronor.<br>Exposed Sox är halvsyster till <strong>Martin de Bos </strong>(e. Maharajah) 1.10,5am/3.098.508 kr, <strong>All In Sox</strong> (e. Ready Cash) 1.13,0am/248.252 kr samt <strong>High Roller Sox</strong> (e. Ready Cash) 1.13,9/225.843 kr.</p>



<figure class="wp-block-image aligncenter size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2020/11/martinbrosprixdavranches-617x322.jpg" alt="" class="wp-image-120021"/><figcaption class="wp-element-caption">Martin de Bos och Franck Nivard vid seger på Vincennes. Igår vann hans lillasyster Exposed Sox på Solvalla. Foto: Gerard Forni</figcaption></figure>



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



<p class="has-drop-cap">7 Svensk Travsport informerar om nya värderingshandlingar som behöver lämnas in på aktuellt startande häst om man planerar att åka och tävla på norsk mark.<br>Regeln gäller från och med 1 februari och blanketten ska skickas in till det norska travförbundet i samband med att man gör startanmälan för tävling i Norge.<br>&#8221;<em>Skickar man inte in någon värdering på hästen i tid kan Norska Travförbundet inte utfärda några tullpapper vilket behövs för att åka till Norge</em>&#8221;, skriver ST.</p>



<p>För svenska tränare kan det vara läge att vara extra uppmärksam kring detta då det sannolikt kommer finnas många blågula intressen på Momarken lördag den 18 mars då det körs en &#8221;norsk-svensk&#8221; V75-omgång med STL-klasser.</p>



<p><a href="http://Blanketten med värderingen mailas till post@travsport.no senast i samband med att man gör startanmälan för tävling i Norge. Skickar man inte in någon värdering på hästen i tid kan Norska Travförbundet inte utfärda några tullpapper vilket behövs för att åka till Norge." target="_blank" rel="noreferrer noopener">Här kan du läsa om reglerna i sin helhet.</a></p>

Fokustema
Morgonsvepet
Läs senare
31 svenskhopp på Vincennes
I dagens morgonsvep behandlas bland annat PDA-helgens alla svenskhopp på Vincennes, derbyfinalist till Håkan K Persson samt Face Time Bourbon-dottern som blev årets sjätte treåriga segerhäst på svensk mark.
