
<p class="has-drop-cap">Det var längesen det kändes så självklart att spika en häst som inte är favorit på V75 som de gör denna vecka.</p>



<p>När<strong> Riet Hazelaar </strong>(V75-3) gör tävlingsdebut för Daniel Wäjersten i en Bronsdivision där hon med närmare 1,7 miljoner kronor intjänat har propositionsmässig fördel som stå kan vi inte låta bli att lägga alla ägg i samma korg.</p>



<p>Under fjolåret slutade S.J.&#8217;s Caviar-dottern tvåa i två bra upplagor av Stoeliten och vi utgår ifrån att Bergsåkerstränaren har haft detta lopp i sikte under en längre period.<br>När det aviseras skoryck och jänkarvagn direkt tänker inte vi stå vid sidan om och titta på och är mycket, mycket förvånade över att inte stoet är spelfavorit på V75 i skrivande stund.</p>



<p><strong>Mellby Knekt </strong>(V75-1) är däremot storfavorit i Klass I-försöket och det säger vi inget om. Han står inför en mycket lämplig uppgift som vi tror att han löser och kan därmed kosta på oss fyra streck i Paralympiatravets uttagningslopp (V75-6) som känns som en smålömsk historia där &#8221;allt och alla&#8221; kan sitta bra till inför det långa upploppet.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2024/04/13v75.pdf" target="_blank" rel="noreferrer noopener">Här kan du ta del av startlistor till tävlingarna på Bergsåker.</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_2024-04-13_9_5" target="_blank" rel="noreferrer noopener">Sulkysport Lilla V75 – 15 andelar á 75 kr/styck</a></p>



<p><a href="https://www.atg.se/andelskungen/spel/206688_V75_2024-04-13_9_5" target="_blank" rel="noreferrer noopener">Sulkysport V75 – 15 andelar á 150 kr/styck</a></p>



<h2 class="wp-block-heading">Avd 1 – Klass I, 2.640 meter autostart</h2>



<ul class="wp-block-list">
<li><strong>Mellby Knekt</strong> är alltjämt obesegrad i felfritt lopp med fyra fullträffar på sex försök. Han gick ut som storfavorit i samma klass vid startren på Romme i början av januari, men slog då på dubbla galopper och hade inte sin bästa dag. Nu har hästen fått ladda om sina batterier och vi påminner om vilket häftigt intryck hästen gav vid segrarna under hösten då han såg närmast okörd ut. Därtill har hästen bevisat att han kan öppna raskt och från innerspår bakom bilen har han frontat tidigare.</li>



<li><strong>The Flying Eagle </strong>fick gå på i relativt högt tempo i Klass II-finalen senast på Solvalla och höll farten starkt som tvåa bakom Bicc&#8217;s Tobee. Hästen är segerlös efter fyra försök över lång distans, men känns ändå relativt rejäl och vi vill inte kategorisera honom som distanssvag.</li>



<li><strong>The Pirate</strong> står lämpligt inne i klassen och har precis som merparten av Andreas Lövdals hästar visat god form under årsinledningen. Sexåringen höll farten starkt från dödens i senaste starten bakom Mercenary och nu är han därtill anmäld barfota runt om precis som vid segerloppet dessförinnan i Mantorp.</li>



<li><strong>Mellby Kaliber </strong>har lyft i årets årets starter. Han fick lägga en speed för att komma till tät senast på Solvalla, men stod pall för den öppningen. Från spår sju bakom bilen föreligger det vingelrisk och vi har svårt att se honom besegra Mellby Knekt från dödens även om hästen som nämnt har rätt kurva.</li>



<li><strong>Nikylon</strong> stod för en mycket bra insats senast i Gävle då han löste uppgiften trots startgalopp. Hästen har verkligen god styrka, men över två och ett halvt varv kan det även behövas viss speed och vi ställer oss lite tveksamma till om han äger den egenskapen.</li>
</ul>



<p><strong>Rank:</strong></p>



<p><strong>A: </strong>1 <strong>B: </strong>4-2-7-10-6-12-5-9 <strong>C: </strong>11-3</p>



<p><strong>Spetsstriden: </strong>Klar fördel för <strong>Mellby Knekt</strong> som frontade från samma utgångsläge på Solvalla i november och på Bergsåker är innerspår bakom bilen ännu bättre. Skulle han göra bort sig så tror vi <strong>The Flying Eagle </strong>når ledningen.</p>



<h2 class="wp-block-heading">Avd 2 – Klass II, 1.640 meter autostart</h2>



<ul class="wp-block-list">
<li><strong>Spike M.M.</strong> inledde karriären med fyra raka segrar innan han gick på pumpen i senaste starten. Då öppnade han jättebra från spår åtta bakom bilen, men blev uppfångad och fick traska i dödens på Relevant Stride. Det är en topphäst som han enkelt enkelt inte lyckades ta sig förbi och fick nöja sig med sjätteplatsen, men insatsen var det inget fel på. Någon häst av det snittet tycker vi inte att han möter id et här loppet och även om han inte skulle nå tät i vad som ser ut att vara en riktigt stökig spetsjakt så kan hästen vinna via andra vägar.</li>



<li><strong>Kingen Mearas </strong>var inte alls sig lik senast i Klass II-försöket på Bjerke, men det kan ha funnits förklaringar. Dels fick hästen göra det otacksamma jobbet som förstahäst i andraspår, men därtill så var de yttre förutsättningarna väldigt krävande. Nu får han åter tävla på hemmaplan och vid segrarna i Daniel Wäjerstens regi tycker vi att fyraåringen gett ett positivt intryck. Fjolårets finalist av långa E3-finalen ska räknas med chans i ett sådant här lopp.</li>



<li><strong>Popeye Tooma </strong>var tvåa i ett stayerlopp inom V75-spelet i Gävle under påsken. Han höll starkt den dagen bakom Nikylon och har tidigare visat så pass duglig startsnabbhet bakom bilen att han har en rimlig chans att fronta från innerspår. Över korta häcken kan vi inte tänka oss annat än att Mika Forss tar chansen och kör i den positionen.</li>



<li><strong>Ninepoints Lady </strong>hakade på helt okej från vinnarhålet senast på Solvalla bakom Joanne Leejs. Vi håller topptrion som bättre hästar, men från ett gynnsamt utgångsläge är hon inte helt utan chans om det klaffar.</li>



<li><strong>Dalens Elvis </strong>satt fast med sparade krafter i senaste starten och nu är fyraåringen anmäld barfota runt om för första gången vilket onekligen kittlar.</li>
</ul>



<p><strong>Rank:</strong></p>



<p><strong>A: </strong>2-4-1 <strong>B: </strong>3-5-7-9-11-6<strong> C: </strong>10-8-12</p>



<p><strong>Spetsstriden: </strong>Svårbedömd inledning då det är startsnabba hästar på de fyra innersta spåren. <strong>Popeye Tooma</strong> öppnade så pass förbättrat senast ur volten att vi kan se honom få en bra start även från innerspår. Annars håller vi <strong>Spike M.M. </strong>som knapp spetsfavorit.</p>



<h2 class="wp-block-heading">Avd 3 – Bronsdivisionen, 2.140 meter autostart</h2>



<ul class="wp-block-list">
<li><strong>Riet Hazelaar</strong> var tvåa i två lopp i Stoeliten under fjolårets. Dels under Copenhagen Cup-dagen bakom Nova Mahiron, men även under Elitloppshelgen bakom Zeudi Amg. Vid båda tillfällena fick hon dra tåget i tredjespår och föll med flaggan i topp. Under höstkanten tappade hon formen aning, men vi tyckte flera av Dion Tesselaars hästar underpresterade den perioden och tar lätt på det faktum. Daniel Wäjersten har haft det här stoet i träning i två månader, är ytterst läskunnig och har kunnat planera in denna uppgift i god tid. Vi bedömer Riet Hazelaar till att ha en enorm fördel propositionsmässigt i detta lopp som &#8221;övermeriterat&#8221; sto och när hon därtill drog vinstlotten i spårtombolan så ser vi det som en självklarhet att spela med henne som singelstreck.</li>



<li><strong>Kaxig In </strong>har David Persson gjort ett mycket bra tränarjobb med. Valacken har stabiliserat sig och nu fått utdelning på den höga kapacitet som han även visade i föregående regi. Dödenssegern senast i Gävle var av det mer imponerande slaget, men hästen är väl så effektiv med ett rygglopp så spår tio grusar inte hans chanser för det.</li>



<li><strong>Kingslayer Pellini </strong>fick jaga Kaxig In från djup köposition i Gävle och slog på en galopp kort före mål i strid om en pallplats. Han tar felsteg mellan varven, men bör trava iväg från innerspår och stod dessförinnan för en mycket stark årsdebut då han var dödenstvåa.</li>



<li><strong>No Limit Express </strong>var hästen som besegrade Kingslayer Pellini i Östersund coh han var i sin tur tvåa bakom Kaxig In i efterföljande start efter att gnuggat tredjespår sista 700 meterna. Oscar Berglunds häst står sig bra i denna klass, men det föreligger dödensrisk på Riet Hazelaar vid laddning.</li>



<li><strong>Mahala</strong> gjorde två bra sulkyinsatser på Vincennes i vintras utan att få så mycket prispengar med sig hem. Hon har haft en fin utvecklingskurva rent allmänt de sista åtta månaderna, men vi tycker helt sonika att Riet Hazelaar är en för tuff konkurrent för Mahala.</li>
</ul>



<p><strong>Rank:</strong></p>



<p><strong>A: </strong>3 <strong>B: </strong>10-1-5-4-12-6-8 <strong>C: </strong>11-9-7-2</p>



<p><strong>Spetsstriden: Riet Hazelaar</strong> öppnar bra och har god chans att komma förbi de invändiga direkt. <strong>No Limit Express </strong>och <strong>Balotelli Face</strong> bedömer vi till att vara ungefär jämnsnabba initialt, men frågan är hur pass &#8221;påslaget&#8221; det är att ladda från de händerna när det föreligger dödensrisk.</p>



<h2 class="wp-block-heading">Avd 4 – Dubbelcupen, final, 2.140 meter voltstart</h2>



<ul class="wp-block-list">
<li><strong>Sol Storm</strong> har haft en mycket fin inledning av detta år och ska nu försöka kröna det med seger i finalen av Dubbelcupen. Hanna Forslins häst var stor i nederlaget bakom en så pass bra häst som Tekno Jerven näst senast på Bergsåker, vann väldigt lätt i efterföljande start efter ett offensivt upplägg och har visat att han tål att göra jobbet själv. Vi tycker att han ska gälla som favorit även om det är tufft att spika honom från dubbla tillägg i småtuff konkurrens.</li>



<li><strong>Blomsterprinsen</strong> har tillhört skiktet under de bästa i sin kull som tre- och fyraåring. Femåringen har tagit stora steg i sin utveckling under vintern och inlett detta år med fyra raka segrar på övertygande vis. Vi tror inte att Mats E Djuse lämnar något åt slumpen här utan försöker ta ett tidigt initiativ och kanske rentav kan forcera sin häst till ledningen.</li>



<li><strong>Brageson</strong> satt fast med sparade krafter senast bakom Guli Em som nu startar 20 meter bakom och det är klart att det är gynnsamt för Bragesons del. Därtill aviseras det skoryck denna gång vilket kittlar och Brageson är given att ha högt upp i ranken för vår del.</li>



<li><strong>Guli Em</strong> höll emot från ledningen senast även om det blev tajt i mål sista biten. Hästen har inlett det här året riktigt bra och även om han står 20 meter sämre till nu gentemot Brageson så går det inte golva honom i tipset.</li>



<li><strong>Tekno Filur</strong> nådde dött lopp med <strong>Basisten </strong>senast i Bollnäs och kan skaffa sig en fin position långt fram i fältet per omgående som startande från innerspår på 20 meters tillägg när det blott är två hästar med på startvolten.</li>
</ul>



<p><strong>Rank:</strong></p>



<p><strong>A: </strong>13-6 <strong>B: </strong>5-14-3-4-15-8-9-12-7 <strong>C: </strong>11-2-10-1</p>



<p><strong>Spetsstriden: Tekno Tana</strong> bör ta en längd på <strong>B.G.Ramona M. </strong>direkt. Även om hon körs i tät har vi svårt att se henne hålla hela vägen. Vi förväntar oss tidigt initiativ av såväl <strong>Brageson</strong> som <strong>Blomsterprinsen</strong>.</p>



<h2 class="wp-block-heading">Avd 5 – Silverdivisionen, 2.640 meter autostart</h2>



<ul class="wp-block-list">
<li><strong>Winterburn</strong> stod för en häftig prestation då han vann Bronsdivisionens final på Solvalla trots en resa utvändigt om ledaren Moses Boko. Den prestationen var värd högsta betyg och skvallrade om en tuffhet hos sexåringen som kommer väl till pass över den dryga distans som han ska ut och tävla över denna lördag. Dock föreligger det dödensrisk ånyo på en bra häst och i en högre klass så vi vågar inte lägga alla ägg i samma korg.</li>



<li><strong>Jerka Sting </strong>höll bra ute i spåren senast i Silverdivisionsförsöket på Romme där han var fyra. Klockan visade 1.10 för hans avslutande 800 meter och det var en stark prestation som färsk i klassen. Nu är sjuåringen anmäld barfota runt om vilket är ett stort plus och som sannolik ledare av loppet känns han inte mindre intressant.</li>



<li><strong>H.C.&#8217;s Crazy Horse </strong>var segermogen senast i ett överpacat lopp med två genomkörare innanför västen. Daniel Wäjerstens häst kvalade in till Kungapokalen ifjol vilket skvallrar om en hög högstanivå och det kittlar att hästen nu ska tävla med jänkarvagn för första gången någonsin.</li>



<li><strong>O&#8217;Mara Zon</strong> fick göra allt jobb själv under slutrundan i årsdebuten vilket på intet vis var optimalt. Har hon inte tagit skada av den upplevelsen så hävdar hon sig säkerligen bra i Silverdivisionen och nu växlas det därtill upp med barfotabalans samt jänkarvagn.</li>



<li><strong>Hannibal Face </strong>gör gedigna lopp för jämnan även om det känns som det finns en nivå till inombords i hästen. Stall Goops hästar går rent allmänt väldigt bra för dagen och det blir intressant att se om Hannibal Face sveps med i det efter en kortare tävlingspaus.</li>
</ul>



<p><strong>Rank:</strong></p>



<p><strong>A: </strong>6-2 <strong>B: </strong>8-3-5-11-10-9-1-7 <strong>C: </strong>12</p>



<p><strong>Spetsstriden: Jerka Sting</strong> har god chans att hålla ut <strong>O&#8217;Mara Zon</strong> initialt.</p>



<h2 class="wp-block-heading">Avd 6 – Gulddivisionen, 2.140 meter autostart</h2>



<ul class="wp-block-list">
<li><strong>Mellby Jinx </strong>mådde gott av ett lopp i kroppen och var aldrig nära att tappa greppet om Nuncios lopp i förra veckan på Solvalla. Från ledningen avslutade han 1.07,9 sista 500 meterna och vann med tillsynes gott om sparade krafter. Här finns det riktiga startraketer på utsidan, men vi håller ändå honom som spetsfavorit och tror att han blir väldigt svårpasserad om inte öppningen äger rum i överljudsfart.</li>



<li><strong>Kentucky River </strong>spurtade strålande som fyra vid Vincennes-starten i januari och stod för en lovande comeback senast på Romme. Då som nu hade han innerspår bakom bilen och var chanslös på att hålla upp ledningen, men bet i fint över spurtrakan när luckan kom. Han gick i mål med full fart över mållinjen utan att tömmas och blir livsfarlig i det här loppet om det blir minsta körning som utmanar Mellby Jinx under vägen.</li>



<li><strong>Castor the Star </strong>var med i en tuff öppning i comebacken innan han backades ner i vinnarhålet en kort period. Det löste sig vettigt till slut och hästen stod för en stark årsdebut som lyckades spurta till vinst. Segerchansen ökar markant om han kommer förbi Mellby Jinx direkt, men Castor the Star är inte utan chans med en ryggresa.</li>



<li><strong>Mister Hercules </strong>omges ett positiva träningsrapporter inför sin årsdebut, men sedan återstår det att se om han har med sig tempot som krävs. Att fjolårets Elitloppsdeltagare är bra nog för att matcha de här hästarna är bevisat sedan tidigare, men dagsstatusen är som nämnt svårbedömd.</li>



<li><strong>Weekend Fun </strong>har gått jättebra under senvintern och början av våren, men när han nu ska ut och möta &#8221;sommarhästar&#8221; så tror vi att han får svårt att bärga en tredje seger i följd.</li>
</ul>



<p><strong>Rank:</strong></p>



<p><strong>A: </strong>2-1 <strong>B: </strong>4-8 <strong>C: </strong>5-7-3-6</p>



<p><strong>Spetsstriden: </strong>Även om innerspår är väldigt gynnsamt på Bergsåker så tror vi inte att <strong>Kentucky River </strong>kan hålla ut <strong>Mellby Jinx</strong>. Han ska i sin tur ha rimlig chans att hålla ut raketen <strong>Castor the Star </strong>och <strong>Weekend Fun</strong> för det har han lyckats med vid tidigare möten hästarna emellan.</p>



<h2 class="wp-block-heading">Avd 7 – Diamantstoet, 2.140 meter voltstart</h2>



<ul class="wp-block-list">
<li><strong>Mi Amore Bros </strong>kvalade in till Derbystoet under fjolåret, men fick inga prispengar med sig den dagen och är därmed alltjämt hemmahörande i en relativt låg klass. Hon avslutade fjolåret med att vinna ett Diamantstoförsök från dödens och vi förutspår att hon är den häst i detta sammanhang som kommer tjäna mest prispengar under året. Det låter därtill förberett inför återkomsten så i ett öppet lopp ser vi henne som den häst med högst vinstchans.</li>



<li><strong>Never To Young </strong>stod för en stark upphämtning efter startgalopp senast i Gävle. Per Lennartssons sto är tuff och tål att göra jobbet själv om så skulle krävas, men givetvis ökar chanserna markant om hon får en så pass bra start från springspår att hon når ledningen av egen kraft eller släpps fram till den positionen.</li>



<li><strong>Olly Håleryd </strong>gör årsdebut, men har bra statistik sedan tidigare i återkomster med tre fullträffar på fyra försök efter paus. Björn Goop får chansen bakom stoet i Ove A Lindqvists frånvaro och då det låter som stoet är väl förberedd inför sin återkomst så räknar vi med en god prestation direkt.</li>



<li><strong>Mercedes Hall </strong>kunde dämpa farten framme i tät senast och hade då inga problem att gå undan till slut. Karriärens segrar är tagna från ledningen, men vi uppfattar henne likväl som en häst som även kan göra bra prestationer via ryggresa.</li>



<li><strong>Dutchess Sun </strong>var finalist i norska Derbystoet ifjol efter att vunnit sitt försökslopp, men fick nöja sig med en åttondeplats den gången. Hon gör intressant debut i Daniel Wäjerstens regi, men tävlar i en relativt hög klass och vi kastar oss inte över henne med hull och hår.</li>
</ul>



<p><strong>Rank:</strong></p>



<p><strong>A: </strong>9-7<strong> B: </strong>14-5-10-15-2-3-6-11-4-12 <strong>C: </strong>13-1-8</p>



<p><strong>Spetsstriden: </strong>Den här inledningen känns riktigt stökig och svårbedömd. Vi är inte alls säkra på att det bara bär iväg till tät för springspårshästarna utan här kan vi se såväl <strong>Polar Operation</strong>, <strong>Icicle Am</strong> och <strong>Dino Cream</strong> utmana i spetsjakten.</p>



<p>	
				<div class="factbox full ">
			<div class="insidefactbox">
				<div class="overflow">
					<div class="height">
						<div class="padding">
							<div class="factvinjett">Fakta</div>
							
															<h3 class="title">
									V75-FÖRSLAGET 13 APRIL								</h3>
														<div class="content">
								
<p><strong>Avd 1: </strong>1 Mellby Knekt (4,2)<br><strong>Avd 2: </strong>1,2,4 (3,5)<br><strong>Avd 3: </strong>3 Riet Hazelaar (10,1)<br><strong>Avd 4: </strong>3,4,5,6,7,8,9,12,13,14,15 (11,2)<br><strong>Avd 5: </strong>2,6,8 (3,5)<br><strong>Avd 6: </strong>1,2,4,8 (5,7)<br><strong>Avd 7: </strong>2,3,4,5,6,7,9,10,11,12,14,15 (13,1)</p>



<p><em>4.752 rader / 2.376 kronor</em></p>
							</div>
						</div>
					</div>
				</div>
							</div>
		</div>
	
	</p>
